Release 1.12.1

fix: do not shadow TMPDIR variable
This enables usage of the plugin with libpam-tmpdir. Refs dokku/dokku#3149
2021-01-17 21:16:14 -05:00 · 2021-01-17 21:02:28 -05:00 · 2020-09-30 12:49:29 -04:00 · 2020-09-30 12:49:03 -04:00 · 2020-09-27 12:38:50 -04:00 · 2020-09-25 10:20:32 +02:00
22 changed files with 1306 additions and 257 deletions
--- a/.circleci/config.yml
+++ b/.circleci/config.yml
@@ -0,0 +1,60 @@
+version: 2.1
+
+commands:
+  build:
+    description: "run the build"
+    parameters:
+      python_version:
+        type: string
+        default: "3.7.0"
+    steps:
+      - checkout
+      - run: pyenv global << parameters.python_version >>
+      - run: make setup
+      - run: sudo sysctl -w vm.max_map_count=262144
+      - run:
+          command: |
+            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
+      - run: make test
+      - store_artifacts:
+          path: build
+          destination: build
+      - store_artifacts:
+          path: tmp/test-results
+          destination: test-results
+      - store_test_results:
+          path: tmp/test-results
+
+executors:
+  machine:
+    machine:
+      docker_layer_caching: false
+      image: ubuntu-1604:201903-01
+
+jobs:
+  build-master:
+    environment:
+      DOKKU_VERSION: master
+    executor: machine
+    steps:
+      - build
+
+  build-version:
+    environment:
+      DOKKU_VERSION: v0.19.0
+    executor: machine
+    steps:
+      - build
+
+workflows:
+  version: 2
+  build:
+    jobs:
+      - "build-master"
+      - "build-version"
--- a/.travis.yml
+++ b/.travis.yml
@@ -1,9 +0,0 @@
-dist: trusty
-language: bash
-env:
-  - DOKKU_VERSION=master
-  - DOKKU_VERSION=v0.14.0
-  - DOKKU_VERSION=v0.12.0
-install: make setup
-script: make test
-after_failure: make report
--- a/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/29
+++ b/29
@@ -1,5 +1,9 @@
 HARDWARE = $(shell uname -m)
 SYSTEM_NAME  = $(shell uname -s | tr '[:upper:]' '[:lower:]')
+SHFMT_VERSION = 3.0.2
+XUNIT_TO_GITHUB_VERSION = 0.3.0
+XUNIT_READER_VERSION = 0.1.0
+

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

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

@@ -73,7 +83,9 @@ setup:

 test: lint unit-tests

-report: tmp/xunit-to-github
+report: tmp/xunit-reader tmp/xunit-to-github
+	tmp/xunit-reader -p 'tmp/test-results/bats/*.xml'
+	tmp/xunit-reader -p 'tmp/test-results/shellcheck/*.xml'
 ifdef TRAVIS_REPO_SLUG
 ifdef GITHUB_ACCESS_TOKEN
 ifneq ($(TRAVIS_PULL_REQUEST),false)
@@ -81,3 +93,14 @@ ifneq ($(TRAVIS_PULL_REQUEST),false)
 endif
 endif
 endif
+
+.PHONY: clean
+clean:
+	rm -f README.md
+
+.PHONY: generate
+generate: clean README.md
+
+.PHONY: README.md
+README.md:
+	bin/generate
--- a/README.md
+++ b/README.md
@@ -1,78 +1,126 @@
-# dokku mysql [![Build Status](https://img.shields.io/travis/dokku/dokku-mysql.svg?branch=master "Build Status")](https://travis-ci.org/dokku/dokku-mysql) [![IRC Network](https://img.shields.io/badge/irc-freenode-blue.svg "IRC Freenode")](https://webchat.freenode.net/?channels=dokku)
+# dokku mysql [![Build Status](https://img.shields.io/circleci/project/github/dokku/dokku-mysql.svg?branch=master&style=flat-square "Build Status")](https://circleci.com/gh/dokku/dokku-mysql/tree/master) [![IRC Network](https://img.shields.io/badge/irc-freenode-blue.svg?style=flat-square "IRC Freenode")](https://webchat.freenode.net/?channels=dokku)

-Official mysql plugin for dokku. Currently defaults to installing [mysql 5.7.25](https://hub.docker.com/_/mysql/).
+Official mysql plugin for dokku. Currently defaults to installing [mysql 5.7.28](https://hub.docker.com/_/mysql/).

-## requirements
+## Requirements

 - dokku 0.12.x+
 - docker 1.8.x

-## installation
+## Installation

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

-## commands
+## Commands

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

 ```shell
-# create a mysql service named lolipop
-dokku mysql:create lolipop
+# usage
+dokku mysql: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 mysql image
-export MYSQL_IMAGE="mysql"
-export MYSQL_IMAGE_VERSION="5.5"
-dokku mysql:create lolipop
+flags:

-# you can also specify custom environment
-# variables to start the mysql service
-# in semi-colon separated form
-export MYSQL_CUSTOM_ENV="USER=alpha;HOST=beta"
-dokku mysql:create lolipop
+- `-C|--custom-env "USER=alpha;HOST=beta"`: semi-colon delimited environment variables to start the service with
+- `-i|--image IMAGE`: the image name to start the service with
+- `-I|--image-version IMAGE_VERSION`: the image version to start the service with
+- `-p|--password PASSWORD`: override the user-level service password
+- `-r|--root-password PASSWORD`: override the root-level service password

-# get connection information as follows
+Create a mysql service named lolipop:
+
+```shell
+dokku mysql:create lolipop
+```
+
+You can also specify the image and image version to use for the service. It *must* be compatible with the mysql image. 
+
+```shell
+export DATABASE_IMAGE="mysql"
+export DATABASE_IMAGE_VERSION="${PLUGIN_IMAGE_VERSION}"
+dokku mysql:create lolipop
+```
+
+You can also specify custom environment variables to start the mysql service in semi-colon separated form. 
+
+```shell
+export DATABASE_CUSTOM_ENV="USER=alpha;HOST=beta"
+dokku mysql:create lolipop
+```
+
+### print the service information
+
+```shell
+# usage
+dokku mysql:info <service> [--single-info-flag]
+```
+
+flags:
+
+- `--config-dir`: show the service configuration directory
+- `--data-dir`: show the service data directory
+- `--dsn`: show the service DSN
+- `--exposed-ports`: show service exposed ports
+- `--id`: show the service container id
+- `--internal-ip`: show the service internal ip
+- `--links`: show the service app links
+- `--service-root`: show the service root directory
+- `--status`: show the service running status
+- `--version`: show the service image version
+
+Get connection information as follows:
+
+```shell
 dokku mysql:info lolipop
+```

-# you can also retrieve a specific piece of service info via flags
+You can also retrieve a specific piece of service info via flags:
+
+```shell
 dokku mysql:info lolipop --config-dir
 dokku mysql:info lolipop --data-dir
 dokku mysql:info lolipop --dsn
@@ -83,165 +131,526 @@ dokku mysql:info lolipop --links
 dokku mysql:info lolipop --service-root
 dokku mysql:info lolipop --status
 dokku mysql:info lolipop --version
+```

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

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

-# a mysql 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 mysql:link lolipop playground
+List all services:

-# the following environment variables will be set automatically by docker (not
-# on the app itself, so they won’t be listed when calling dokku config)
-#
-#   DOKKU_MYSQL_LOLIPOP_NAME=/lolipop/DATABASE
-#   DOKKU_MYSQL_LOLIPOP_PORT=tcp://172.17.0.1:3306
-#   DOKKU_MYSQL_LOLIPOP_PORT_3306_TCP=tcp://172.17.0.1:3306
-#   DOKKU_MYSQL_LOLIPOP_PORT_3306_TCP_PROTO=tcp
-#   DOKKU_MYSQL_LOLIPOP_PORT_3306_TCP_PORT=3306
-#   DOKKU_MYSQL_LOLIPOP_PORT_3306_TCP_ADDR=172.17.0.1
-#
-# and the following will be set on the linked application by default
-#
-#   DATABASE_URL=mysql://mysql:SOME_PASSWORD@dokku-mysql-lolipop:3306/lolipop
-#
-# NOTE: the host exposed here only works internally in docker containers. If
-# you want your container to be reachable from outside, you should use `expose`.
+```shell
+dokku mysql:list
+```

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

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

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

-# this will replace DATABASE_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:
-#
-#   DATABASE_URL=mysql://mysql:ANOTHER_PASSWORD@dokku-mysql-other_service:3306/other_service
-#   DOKKU_MYSQL_BLUE_URL=mysql://mysql:ANOTHER_PASSWORD@dokku-mysql-other-service:3306/other_service
-#   DOKKU_MYSQL_SILVER_URL=mysql://mysql:SOME_PASSWORD@dokku-mysql-lolipop:3306/lolipop
+- `-t|--tail`: do not stop when end of the logs are reached and wait for additional output

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

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

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

-It's possible to change the protocol for DATABASE_URL by setting
-the environment variable MYSQL_DATABASE_SCHEME on the app:
+```shell
+dokku mysql:logs lolipop --tail
+```
+
+### link the mysql service to the app
+
+```shell
+# usage
+dokku mysql: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 mysql 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 mysql:link lolipop playground
+```
+
+The following environment variables will be set automatically by docker (not on the app itself, so they won’t be listed when calling dokku config):

 ```
+DOKKU_DATABASE_LOLIPOP_NAME=/lolipop/DATABASE
+DOKKU_DATABASE_LOLIPOP_PORT=tcp://172.17.0.1:3306
+DOKKU_DATABASE_LOLIPOP_PORT_3306_TCP=tcp://172.17.0.1:3306
+DOKKU_DATABASE_LOLIPOP_PORT_3306_TCP_PROTO=tcp
+DOKKU_DATABASE_LOLIPOP_PORT_3306_TCP_PORT=3306
+DOKKU_DATABASE_LOLIPOP_PORT_3306_TCP_ADDR=172.17.0.1
+```
+
+The following will be set on the linked application by default:
+
+```
+DATABASE_URL=mysql://lolipop:SOME_PASSWORD@dokku-mysql-lolipop:3306/lolipop
+```
+
+The host exposed here only works internally in docker containers. If you want your container to be reachable from outside, you should use the 'expose' subcommand. Another service can be linked to your app:
+
+```shell
+dokku mysql:link other_service playground
+```
+
+It is possible to change the protocol for `DATABASE_URL` by setting the environment variable `MYSQL_DATABASE_SCHEME` on the app. Doing so will after linking will cause the plugin to think the service is not linked, and we advise you to unlink before proceeding. 
+
+```shell
 dokku config:set playground MYSQL_DATABASE_SCHEME=mysql2
 dokku mysql:link lolipop playground
 ```

-Will cause DATABASE_URL to be set as
-mysql2://mysql:SOME_PASSWORD@dokku-mysql-lolipop:3306/lolipop
+This will cause `DATABASE_URL` to be set as:

-CAUTION: Changing MYSQL_DATABASE_SCHEME after linking will cause dokku to
-believe the service is not linked when attempting to use `dokku mysql:unlink`
-or `dokku mysql:promote`.
-You should be able to fix this by
+```
+mysql2://lolipop:SOME_PASSWORD@dokku-mysql-lolipop:3306/lolipop
+```

- Changing DATABASE_URL manually to the new value.
+### unlink the mysql service from the app

-OR
+```shell
+# usage
+dokku mysql:unlink <service> <app>
+```

- Set MYSQL_DATABASE_SCHEME back to its original setting
- Unlink the service
- Change MYSQL_DATABASE_SCHEME to the desired setting
- Relink the service
+You can unlink a mysql service:

-## Configuration
+> NOTE: this will restart your app and unset related environment variables

-It is possible to add custom configuration settings.
-`/etc/mysql/conf.d` is mapped to the output of `dokku mysql:info SERVICE --config-dir`
+```shell
+dokku mysql:unlink lolipop playground
+```

-Any files placed in this folder will be loaded. If a file is changed you will need
-to reload your database for the changes to take effect.
+### Service Lifecycle

-For more information on configuration options see https://dev.mysql.com/doc/refman/5.7/en/option-files.html
+The lifecycle of each service can be managed through the following commands:

-> Note: This plugin mounts a host directory into the container under `/etc/mysql/conf.d`. Custom images that have files in this directory will have those files overwritten by the mount.
+### connect to the service via the mysql connection tool
+
+```shell
+# usage
+dokku mysql:connect <service>
+```
+
+Connect to the service via the mysql connection tool:
+
+```shell
+dokku mysql:connect lolipop
+```
+
+### enter or run a command in a running mysql service container
+
+```shell
+# usage
+dokku mysql:enter <service>
+```
+
+A bash prompt can be opened against a running service. Filesystem changes will not be saved to disk. 
+
+```shell
+dokku mysql:enter lolipop
+```
+
+You may also run a command directly against the service. Filesystem changes will not be saved to disk. 
+
+```shell
+dokku mysql:enter lolipop touch /tmp/test
+```
+
+### expose a mysql service on custom port if provided (random port otherwise)
+
+```shell
+# usage
+dokku mysql: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 mysql:expose lolipop 3306
+```
+
+### unexpose a previously exposed mysql service
+
+```shell
+# usage
+dokku mysql:unexpose <service>
+```
+
+Unexpose the service, removing access to it from the public interface (`0.0.0.0`):
+
+```shell
+dokku mysql:unexpose lolipop
+```
+
+### promote service <service> as DATABASE_URL in <app>
+
+```shell
+# usage
+dokku mysql:promote <service> <app>
+```
+
+If you have a mysql service linked to an app and try to link another mysql service another link environment variable will be generated automatically:
+
+```
+DOKKU_DATABASE_BLUE_URL=mysql://other_service:ANOTHER_PASSWORD@dokku-mysql-other-service:3306/other_service
+```
+
+You can promote the new service to be the primary one:
+
+> NOTE: this will restart your app
+
+```shell
+dokku mysql:promote other_service playground
+```
+
+This will replace `DATABASE_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:
+
+```
+DATABASE_URL=mysql://other_service:ANOTHER_PASSWORD@dokku-mysql-other-service:3306/other_service
+DOKKU_DATABASE_BLUE_URL=mysql://other_service:ANOTHER_PASSWORD@dokku-mysql-other-service:3306/other_service
+DOKKU_DATABASE_SILVER_URL=mysql://lolipop:SOME_PASSWORD@dokku-mysql-lolipop:3306/lolipop
+```
+
+### start a previously stopped mysql service
+
+```shell
+# usage
+dokku mysql:start <service>
+```
+
+Start the service:
+
+```shell
+dokku mysql:start lolipop
+```
+
+### stop a running mysql service
+
+```shell
+# usage
+dokku mysql:stop <service>
+```
+
+Stop the service and the running container:
+
+```shell
+dokku mysql:stop lolipop
+```
+
+### graceful shutdown and restart of the mysql service container
+
+```shell
+# usage
+dokku mysql:restart <service>
+```
+
+Restart the service:
+
+```shell
+dokku mysql:restart lolipop
+```
+
+### upgrade service <service> to the specified versions
+
+```shell
+# usage
+dokku mysql:upgrade <service> [--upgrade-flags...]
+```
+
+flags:
+
+- `-C|--custom-env "USER=alpha;HOST=beta"`: semi-colon delimited environment variables to start the service with
+- `-i|--image IMAGE`: the image name to start the service with
+- `-I|--image-version IMAGE_VERSION`: the image version to start the service with
+- `-R|--restart-apps "true"`: whether to force an app restart
+
+You can upgrade an existing service to a new image or image-version:
+
+```shell
+dokku mysql:upgrade lolipop
+```
+
+### Service Automation
+
+Service scripting can be executed using the following commands:
+
+### list all mysql service links for a given app
+
+```shell
+# usage
+dokku mysql:app-links <app>
+```
+
+List all mysql services that are linked to the 'playground' app. 
+
+```shell
+dokku mysql:app-links playground
+```
+
+### create container <new-name> then copy data from <name> into <new-name>
+
+```shell
+# usage
+dokku mysql:clone <service> <new-service> [--clone-flags...]
+```
+
+flags:
+
+- `-C|--custom-env "USER=alpha;HOST=beta"`: semi-colon delimited environment variables to start the service with
+- `-i|--image IMAGE`: the image name to start the service with
+- `-I|--image-version IMAGE_VERSION`: the image version to start the service with
+- `-p|--password PASSWORD`: override the user-level service password
+- `-r|--root-password PASSWORD`: override the root-level service password
+
+You can clone an existing service to a new one:
+
+```shell
+dokku mysql:clone lolipop lolipop-2
+```
+
+### check if the mysql service exists
+
+```shell
+# usage
+dokku mysql:exists <service>
+```
+
+Here we check if the lolipop mysql service exists. 
+
+```shell
+dokku mysql:exists lolipop
+```
+
+### check if the mysql service is linked to an app
+
+```shell
+# usage
+dokku mysql:linked <service> <app>
+```
+
+Here we check if the lolipop mysql service is linked to the 'playground' app. 
+
+```shell
+dokku mysql:linked lolipop playground
+```
+
+### list all apps linked to the mysql service
+
+```shell
+# usage
+dokku mysql:links <service>
+```
+
+List all apps linked to the 'lolipop' mysql service. 
+
+```shell
+dokku mysql:links lolipop
+```
+
+### Data Management
+
+The underlying service data can be imported and exported with the following commands:
+
+### import a dump into the mysql service database
+
+```shell
+# usage
+dokku mysql:import <service>
+```
+
+Import a datastore dump:
+
+```shell
+dokku mysql:import lolipop < database.dump
+```
+
+### export a dump of the mysql service database
+
+```shell
+# usage
+dokku mysql:export <service>
+```
+
+By default, datastore output is exported to stdout:
+
+```shell
+dokku mysql:export lolipop
+```
+
+You can redirect this output to a file:
+
+```shell
+dokku mysql:export lolipop > lolipop.dump
+```

 ### Backups

 Datastore backups are supported via AWS S3 and S3 compatible services like [minio](https://github.com/minio/minio).

-You may skip the `backup-auth` step if your dokku install is running within EC2
-and has access to the bucket via an IAM profile. In that case, use the `--use-iam`
-option with the `backup` command.
+You may skip the `backup-auth` step if your dokku install is running within EC2 and has access to the bucket via an IAM profile. In that case, use the `--use-iam` option with the `backup` command.

 Backups can be performed using the backup commands:

+### sets up authentication for backups on the mysql service
+
+```shell
+# usage
+dokku mysql:backup-auth <service> <aws-access-key-id> <aws-secret-access-key> <aws-default-region> <aws-signature-version> <endpoint-url>
 ```
-# setup s3 backup authentication
+
+Setup s3 backup authentication:
+
+```shell
 dokku mysql:backup-auth lolipop AWS_ACCESS_KEY_ID AWS_SECRET_ACCESS_KEY
-
-# remove s3 authentication
-dokku mysql:backup-deauth lolipop
-
-# backup the `lolipop` service to the `BUCKET_NAME` bucket on AWS
-dokku mysql:backup lolipop BUCKET_NAME
-
-# schedule a backup
-# CRON_SCHEDULE is a crontab expression, eg. "0 3 * * *" for each day at 3am
-dokku mysql:backup-schedule lolipop CRON_SCHEDULE BUCKET_NAME
-
-# cat the contents of the configured backup cronfile for the service
-dokku mysql:backup-schedule-cat lolipop
-
-# remove the scheduled backup from cron
-dokku mysql:backup-unschedule lolipop
 ```

-Backup auth can also be set up for different regions, signature versions and endpoints (e.g. for minio):
- 
-```
-# setup s3 backup authentication with different region
+Setup s3 backup authentication with different region:
+
+```shell
 dokku mysql:backup-auth lolipop AWS_ACCESS_KEY_ID AWS_SECRET_ACCESS_KEY AWS_REGION
- 
-# setup s3 backup authentication with different signature version and endpoint
+```
+
+Setup s3 backup authentication with different signature version and endpoint:
+
+```shell
 dokku mysql:backup-auth lolipop AWS_ACCESS_KEY_ID AWS_SECRET_ACCESS_KEY AWS_REGION AWS_SIGNATURE_VERSION ENDPOINT_URL
- 
-# more specific example for minio auth
+```
+
+More specific example for minio auth:
+
+```shell
 dokku mysql:backup-auth lolipop MINIO_ACCESS_KEY_ID MINIO_SECRET_ACCESS_KEY us-east-1 s3v4 https://YOURMINIOSERVICE
 ```

-## Disabling `docker pull` calls
+### removes backup authentication for the mysql service
+
+```shell
+# usage
+dokku mysql:backup-deauth <service>
+```
+
+Remove s3 authentication:
+
+```shell
+dokku mysql:backup-deauth lolipop
+```
+
+### creates a backup of the mysql service to an existing s3 bucket
+
+```shell
+# usage
+dokku mysql:backup <service> <bucket-name> [--use-iam]
+```
+
+flags:
+
+- `-u|--use-iam`: use the IAM profile associated with the current server
+
+Backup the 'lolipop' service to the 'my-s3-bucket' bucket on ``AWS`:`
+
+```shell
+dokku mysql:backup lolipop my-s3-bucket --use-iam
+```
+
+### sets encryption for all future backups of mysql service
+
+```shell
+# usage
+dokku mysql:backup-set-encryption <service> <passphrase>
+```
+
+Set the GPG-compatible passphrase for encrypting backups for backups:
+
+```shell
+dokku mysql:backup-set-encryption lolipop
+```
+
+### unsets encryption for future backups of the mysql service
+
+```shell
+# usage
+dokku mysql:backup-unset-encryption <service>
+```
+
+Unset the `GPG` encryption passphrase for backups:
+
+```shell
+dokku mysql:backup-unset-encryption lolipop
+```
+
+### schedules a backup of the mysql service
+
+```shell
+# usage
+dokku mysql: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 mysql:backup-schedule lolipop "0 3 * * *" my-s3-bucket
+```
+
+Schedule a backup and authenticate via iam:
+
+```shell
+dokku mysql:backup-schedule lolipop "0 3 * * *" my-s3-bucket --use-iam
+```
+
+### cat the contents of the configured backup cronfile for the service
+
+```shell
+# usage
+dokku mysql:backup-schedule-cat <service>
+```
+
+Cat the contents of the configured backup cronfile for the service:
+
+```shell
+dokku mysql:backup-schedule-cat lolipop
+```
+
+### unschedules the backup of the mysql service
+
+```shell
+# usage
+dokku mysql:backup-unschedule <service>
+```
+
+Remove the scheduled backup from cron:
+
+```shell
+dokku mysql:backup-unschedule lolipop
+```
+
+### Disabling `docker pull` calls

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

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

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

  docker inspect "$ID" &>/dev/null || dokku_log_fail "Service container does not exist"
  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,7 +218,7 @@ service_backup() {
  fi

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

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

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

 service_linked_apps() {
-  declare desc="Lists all applications linked to a service"
+  declare desc="Lists all apps linked to a service for info output"
  declare SERVICE="$1"
  local SERVICE_ROOT="$PLUGIN_DATA_ROOT/$SERVICE"
  local LINKS_FILE="$SERVICE_ROOT/LINKS"
@@ -479,22 +480,31 @@ service_linked_apps() {
  tr '\n' ' ' <"$LINKS_FILE"
 }

+service_links() {
+  declare desc="Lists all apps linked to a service"
+  declare SERVICE="$1"
+  local SERVICE_ROOT="$PLUGIN_DATA_ROOT/$SERVICE"
+  local LINKS_FILE="$SERVICE_ROOT/LINKS"
+
+  touch "$LINKS_FILE"
+  [[ -z $(<"$LINKS_FILE") ]] && return 0
+
+  cat "$LINKS_FILE"
+}
+
 service_list() {
  declare desc="Lists all services and their status"
  local SERVICES=$(ls "$PLUGIN_DATA_ROOT" 2>/dev/null)
+
  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() {
@@ -586,6 +596,26 @@ service_parse_args() {
  shift "$((OPTIND - 1))" # remove options from positional parameters
 }

+service_password() {
+  declare desc="Fetch the password for a service"
+  declare SERVICE="$1"
+  local SERVICE_ROOT="$PLUGIN_DATA_ROOT/$SERVICE"
+  local PASSWORD_FILE="$SERVICE_ROOT/PASSWORD"
+  if [[ -f "$PASSWORD_FILE" ]]; then
+    cat "$PASSWORD_FILE"
+  fi
+}
+
+service_root_password() {
+  declare desc="Fetch the root password for a service"
+  declare SERVICE="$1"
+  local SERVICE_ROOT="$PLUGIN_DATA_ROOT/$SERVICE"
+  local PASSWORD_FILE="$SERVICE_ROOT/ROOTPASSWORD"
+  if [[ -f "$PASSWORD_FILE" ]]; then
+    cat "$PASSWORD_FILE"
+  fi
+}
+
 service_port_expose() {
  declare desc="Wrapper for exposing service ports"
  declare SERVICE="$1"
@@ -657,7 +687,7 @@ 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.2.0 >/dev/null
+  docker run -d --link "$SERVICE_NAME:$PLUGIN_COMMAND_PREFIX" --name "$EXPOSED_NAME" $(docker_ports_options "${PORTS[@]}") --restart always --label dokku=ambassador --label "dokku.ambassador=$PLUGIN_COMMAND_PREFIX" "$PLUGIN_AMBASSADOR_IMAGE" >/dev/null
  if [[ "$LOG_FAIL" == "true" ]]; then
    dokku_log_info1 "Service $SERVICE exposed on port(s) [container->host]: $(service_exposed_ports "$SERVICE")"
  fi
@@ -708,13 +738,7 @@ service_status() {
  local ID="$(cat "$SERVICE_ROOT/ID")"
  local CONTAINER_STATUS

-  is_container_status "$ID" "Dead" && echo "dead" && return 0
-  is_container_status "$ID" "OOMKilled" && echo "oomkilled" && return 0
-  is_container_status "$ID" "Paused" && echo "paused" && return 0
-  is_container_status "$ID" "Restarting" && echo "restarting" && return 0
-  is_container_status "$ID" "Running" && echo "running" && return 0
-
-  CONTAINER_STATUS=$(docker inspect -f "{{.State.Status}}" "$CID" 2>/dev/null || true)
+  CONTAINER_STATUS=$(docker inspect -f "{{.State.Status}}" "$ID" 2>/dev/null || true)
  [[ -n "$CONTAINER_STATUS" ]] && echo "$CONTAINER_STATUS" && return 0
  echo "missing" && return 0
 }
--- a/8
+++ b/8
@@ -1,6 +1,6 @@
 #!/usr/bin/env bash
 export MYSQL_IMAGE=${MYSQL_IMAGE:="mysql"}
-export MYSQL_IMAGE_VERSION=${MYSQL_IMAGE_VERSION:="5.7.25"}
+export MYSQL_IMAGE_VERSION=${MYSQL_IMAGE_VERSION:="5.7.28"}
 export MYSQL_ROOT=${MYSQL_ROOT:="$DOKKU_LIB_ROOT/services/mysql"}
 export MYSQL_HOST_ROOT=${MYSQL_HOST_ROOT:=$MYSQL_ROOT}

@@ -21,6 +21,12 @@ export PLUGIN_SCHEME="mysql"
 export PLUGIN_SERVICE="MySQL"
 export PLUGIN_VARIABLE="MYSQL"
 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"
--- a/29
+++ b/29
@@ -14,7 +14,7 @@ service_connect() {
  local SERVICE_ROOT="$PLUGIN_DATA_ROOT/$SERVICE"
  local SERVICE_NAME="$(get_service_name "$SERVICE")"
  local DATABASE_NAME="$(get_database_name "$SERVICE")"
-  local PASSWORD="$(cat "$SERVICE_ROOT/PASSWORD")"
+  local PASSWORD="$(service_password "$SERVICE")"
  local SERVICE_TTY_OPTS
  has_tty && SERVICE_TTY_OPTS="-t"

@@ -43,11 +43,11 @@ service_create() {

  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"

-  echo -e "[mysqld]\nperformance_schema = 0" >"$SERVICE_ROOT/config/disable_performance_schema.cnf"
-  echo -e "[mysqld]\ncharacter-set-server = utf8\ncollation-server = utf8_general_ci" >"$SERVICE_ROOT/config/charset_utf8.cnf"
+  echo -e "[mysqld]\nperformance_schema = 0" >"$SERVICE_ROOT/$PLUGIN_CONFIG_SUFFIX/disable_performance_schema.cnf"
+  echo -e "[mysqld]\ncharacter-set-server = utf8\ncollation-server = utf8_general_ci" >"$SERVICE_ROOT/$PLUGIN_CONFIG_SUFFIX/charset_utf8.cnf"
  ROOTPASSWORD=$(openssl rand -hex 8)
  PASSWORD=$(openssl rand -hex 8)
  if [[ -n "$SERVICE_PASSWORD" ]]; then
@@ -78,15 +78,15 @@ service_create_container() {
  local SERVICE_ROOT="$PLUGIN_DATA_ROOT/$SERVICE"
  local SERVICE_HOST_ROOT="$PLUGIN_DATA_HOST_ROOT/$SERVICE"
  local SERVICE_NAME="$(get_service_name "$SERVICE")"
-  local ROOTPASSWORD="$(cat "$SERVICE_ROOT/ROOTPASSWORD")"
-  local PASSWORD="$(cat "$SERVICE_ROOT/PASSWORD")"
+  local ROOTPASSWORD="$(service_root_password "$SERVICE")"
+  local PASSWORD="$(service_password "$SERVICE")"
  local DATABASE_NAME="$(get_database_name "$SERVICE")"

-  ID=$(docker run --name "$SERVICE_NAME" -v "$SERVICE_HOST_ROOT/data:/var/lib/mysql" -v "$SERVICE_HOST_ROOT/config:/etc/mysql/conf.d" -e "MYSQL_ROOT_PASSWORD=$ROOTPASSWORD" -e MYSQL_USER=mysql -e "MYSQL_PASSWORD=$PASSWORD" -e "MYSQL_DATABASE=$DATABASE_NAME" --env-file="$SERVICE_ROOT/ENV" -d --restart always --label dokku=service --label dokku.service=mysql "$PLUGIN_IMAGE:$PLUGIN_IMAGE_VERSION")
+  ID=$(docker run --name "$SERVICE_NAME" -v "$SERVICE_HOST_ROOT/data:/var/lib/mysql" -v "$SERVICE_HOST_ROOT/$PLUGIN_CONFIG_SUFFIX:/etc/mysql/conf.d" -e "MYSQL_ROOT_PASSWORD=$ROOTPASSWORD" -e MYSQL_USER=mysql -e "MYSQL_PASSWORD=$PASSWORD" -e "MYSQL_DATABASE=$DATABASE_NAME" --env-file="$SERVICE_ROOT/ENV" -d --restart always --label dokku=service --label dokku.service=mysql "$PLUGIN_IMAGE:$PLUGIN_IMAGE_VERSION")
  echo "$ID" >"$SERVICE_ROOT/ID"

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

  dokku_log_info2 "$PLUGIN_SERVICE container created: $SERVICE"
  service_info "$SERVICE"
@@ -97,11 +97,11 @@ service_export() {
  local SERVICE_ROOT="$PLUGIN_DATA_ROOT/$SERVICE"
  local SERVICE_NAME="$(get_service_name "$SERVICE")"
  local DATABASE_NAME="$(get_database_name "$SERVICE")"
-  local PASSWORD="$(cat "$SERVICE_ROOT/PASSWORD")"
+  local PASSWORD="$(service_password "$SERVICE")"

  [[ -n $SSH_TTY ]] && stty -opost
  docker exec "$SERVICE_NAME" bash -c "printf '[client]\npassword=$PASSWORD\n' > /root/credentials.cnf"
-  docker exec "$SERVICE_NAME" mysqldump --defaults-extra-file=/root/credentials.cnf --user=mysql "$DATABASE_NAME"
+  docker exec "$SERVICE_NAME" mysqldump --defaults-extra-file=/root/credentials.cnf --user=mysql --single-transaction --quick  "$DATABASE_NAME"
  docker exec "$SERVICE_NAME" rm /root/credentials.cnf
  status=$?
  [[ -n $SSH_TTY ]] && stty opost
@@ -114,7 +114,7 @@ service_import() {
  local SERVICE_NAME="$(get_service_name "$SERVICE")"
  local SERVICE_HOST_ROOT="$PLUGIN_DATA_HOST_ROOT/$SERVICE"
  local DATABASE_NAME="$(get_database_name "$SERVICE")"
-  local ROOTPASSWORD="$(cat "$SERVICE_ROOT/ROOTPASSWORD")"
+  local ROOTPASSWORD="$(service_root_password "$SERVICE")"

  if [[ -t 0 ]]; then
    dokku_log_fail "No data provided on stdin."
@@ -139,8 +139,8 @@ service_start() {

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

  if [[ -n $PREVIOUS_ID ]]; then
    docker start "$PREVIOUS_ID" >/dev/null
@@ -155,9 +155,8 @@ service_start() {

 service_url() {
  local SERVICE="$1"
-  local SERVICE_ROOT="$PLUGIN_DATA_ROOT/$SERVICE"
  local SERVICE_DNS_HOSTNAME="$(service_dns_hostname "$SERVICE")"
  local DATABASE_NAME="$(get_database_name "$SERVICE")"
-  local PASSWORD="$(cat "$SERVICE_ROOT/PASSWORD")"
+  local PASSWORD="$(service_password "$SERVICE")"
  echo "$PLUGIN_SCHEME://mysql:$PASSWORD@$SERVICE_DNS_HOSTNAME:${PLUGIN_DATASTORE_PORTS[0]}/$DATABASE_NAME"
 }
--- a/12
+++ b/12
@@ -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"
@@ -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}"
--- a/8
+++ b/8
@@ -17,10 +17,10 @@ plugin-install() {
  }

  pull-docker-image "${PLUGIN_IMAGE}:${PLUGIN_IMAGE_VERSION}"
-  pull-docker-image "dokku/ambassador:0.2.0"
-  pull-docker-image "dokku/wait:0.3.0"
-  pull-docker-image "dokku/s3backup:0.9.4"
-  pull-docker-image "busybox:1.30.1-uclibc"
+  pull-docker-image "$PLUGIN_BUSYBOX_IMAGE"
+  pull-docker-image "$PLUGIN_AMBASSADOR_IMAGE"
+  pull-docker-image "$PLUGIN_S3BACKUP_IMAGE"
+  pull-docker-image "$PLUGIN_WAIT_IMAGE"

  mkdir -p "$PLUGIN_DATA_ROOT" || echo "Failed to create $PLUGIN_SERVICE data directory"
  chown dokku:dokku "$PLUGIN_DATA_ROOT"
--- a/plugin.toml
+++ b/plugin.toml
@@ -1,4 +1,4 @@
 [plugin]
 description = "dokku mysql service plugin"
-version = "1.8.1"
+version = "1.12.1"
 [plugin.config]
--- a/subcommands/backup-set-encryption
+++ b/subcommands/backup-set-encryption
@@ -6,7 +6,7 @@ source "$PLUGIN_BASE_PATH/common/functions"
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/functions"

 service-backup-set-encryption-cmd() {
-  #E set a GPG passphrase for backups
+  #E set the GPG-compatible passphrase for encrypting backups for backups
  #E dokku $PLUGIN_COMMAND_PREFIX:backup-set-encryption lolipop
  #A service, service to run command against
  #A passphrase, a GPG-compatible passphrase
--- a/subcommands/backup-unset-encryption
+++ b/subcommands/backup-unset-encryption
@@ -6,7 +6,7 @@ source "$PLUGIN_BASE_PATH/common/functions"
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/functions"

 service-backup-unset-encryption-cmd() {
-  #E unset a GPG encryption key for backups
+  #E unset the GPG encryption passphrase for backups
  #E dokku $PLUGIN_COMMAND_PREFIX:backup-unset-encryption lolipop
  #A service, service to run command against
  declare desc="unsets encryption for future backups of the $PLUGIN_SERVICE service"
--- a/subcommands/destroy
+++ b/subcommands/destroy
@@ -45,7 +45,7 @@ service-destroy-cmd() {
  service_container_rm "$SERVICE"

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

  dokku_log_info2 "$PLUGIN_SERVICE container deleted: $SERVICE"
--- a/subcommands/info
+++ b/subcommands/info
@@ -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
@@ -30,10 +30,10 @@ service-link-cmd() {
  #E use the 'expose' subcommand. another service can be linked to your app:
  #E dokku $PLUGIN_COMMAND_PREFIX:link other_service playground
  #E it is possible to change the protocol for ${PLUGIN_DEFAULT_ALIAS}_URL by setting the
-  #E environment variable ${PLUGIN_DEFAULT_ALIAS}_DATABASE_SCHEME on the app. doing so will
+  #E environment variable ${PLUGIN_VARIABLE}_DATABASE_SCHEME on the app. doing so will
  #E after linking will cause the plugin to think the service is not
  #E linked, and we advise you to unlink before proceeding.
-  #E dokku config:set playground ${PLUGIN_DEFAULT_ALIAS}_DATABASE_SCHEME=${PLUGIN_SCHEME}2
+  #E dokku config:set playground ${PLUGIN_VARIABLE}_DATABASE_SCHEME=${PLUGIN_SCHEME}2
  #E dokku $PLUGIN_COMMAND_PREFIX:link lolipop playground
  #E this will cause ${PLUGIN_DEFAULT_ALIAS}_URL to be set as:
  #E
--- a/subcommands/links
+++ b/subcommands/links
@@ -0,0 +1,24 @@
+#!/usr/bin/env bash
+source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/config"
+set -eo pipefail
+[[ $DOKKU_TRACE ]] && set -x
+source "$PLUGIN_BASE_PATH/common/functions"
+source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/functions"
+
+service-links-cmd() {
+  #E list all apps linked to the 'lolipop' $PLUGIN_COMMAND_PREFIX service.
+  #E dokku $PLUGIN_COMMAND_PREFIX:links lolipop
+  #A service, service to run command against
+  declare desc="list all apps linked to the $PLUGIN_SERVICE service"
+  local cmd="$PLUGIN_COMMAND_PREFIX:links" argv=("$@")
+  [[ ${argv[0]} == "$cmd" ]] && shift 1
+  declare SERVICE="$1"
+  local SERVICE_ROOT="$PLUGIN_DATA_ROOT/$SERVICE"
+  local LINKS_FILE="$SERVICE_ROOT/LINKS"
+
+  [[ -z "$SERVICE" ]] && dokku_log_fail "Please specify a valid name for the service"
+  verify_service_name "$SERVICE"
+  service_links "$SERVICE"
+}
+
+service-links-cmd "$@"
--- a/tests/service_link.bats
+++ b/tests/service_link.bats
@@ -85,7 +85,7 @@ teardown() {

@test "($PLUGIN_COMMAND_PREFIX:link) links to app with docker-options" {
  dokku "$PLUGIN_COMMAND_PREFIX:link" l my_app
-  run dokku docker-options my_app
+  run dokku docker-options:report my_app
  assert_contains "${lines[*]}" "--link dokku.mysql.l:dokku-mysql-l"
  assert_success
  dokku "$PLUGIN_COMMAND_PREFIX:unlink" l my_app
--- a/tests/service_list.bats
+++ b/tests/service_list.bats
@@ -10,27 +10,13 @@ teardown() {
 }

@test "($PLUGIN_COMMAND_PREFIX:list) with no exposed ports, no linked apps" {
-  run dokku "$PLUGIN_COMMAND_PREFIX:list"
-  assert_contains "${lines[*]}" "l     mysql:5.7.25  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     mysql:5.7.25  running  3306->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     mysql:5.7.25  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 MySQL services"
+  assert_output "${lines[*]}" "There are no $PLUGIN_SERVICE services"
  dokku "$PLUGIN_COMMAND_PREFIX:create" l
 }
--- a/tests/setup.sh
+++ b/tests/setup.sh
@@ -1,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
@@ -13,9 +21,10 @@ export DOKKU_LIB_ROOT="/var/lib/dokku"
 export DOKKU_PLUGINS_ROOT="$DOKKU_LIB_ROOT/plugins/available"
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/config"
 sudo rm -rf "$DOKKU_PLUGINS_ROOT/$PLUGIN_COMMAND_PREFIX"
-sudo mkdir -p "$DOKKU_PLUGINS_ROOT/$PLUGIN_COMMAND_PREFIX" "$DOKKU_PLUGINS_ROOT/$PLUGIN_COMMAND_PREFIX/subcommands"
+sudo mkdir -p "$DOKKU_PLUGINS_ROOT/$PLUGIN_COMMAND_PREFIX" "$DOKKU_PLUGINS_ROOT/$PLUGIN_COMMAND_PREFIX/subcommands" "$DOKKU_PLUGINS_ROOT/$PLUGIN_COMMAND_PREFIX/scripts"
 sudo find ./ -maxdepth 1 -type f -exec cp '{}' "$DOKKU_PLUGINS_ROOT/$PLUGIN_COMMAND_PREFIX" \;
-sudo find ./subcommands -maxdepth 1 -type f -exec cp '{}' "$DOKKU_PLUGINS_ROOT/$PLUGIN_COMMAND_PREFIX/subcommands" \;
+[[ -d "./scripts" ]] && sudo find ./scripts -maxdepth 1 -type f -exec cp '{}' "$DOKKU_PLUGINS_ROOT/$PLUGIN_COMMAND_PREFIX/scripts" \;
+[[ -d "./subcommands" ]] && sudo find ./subcommands -maxdepth 1 -type f -exec cp '{}' "$DOKKU_PLUGINS_ROOT/$PLUGIN_COMMAND_PREFIX/subcommands" \;
 sudo mkdir -p "$PLUGIN_CONFIG_ROOT" "$PLUGIN_DATA_ROOT"
 sudo dokku plugin:enable "$PLUGIN_COMMAND_PREFIX"
 sudo dokku plugin:install
--- a/tests/shellcheck-exclude
+++ b/tests/shellcheck-exclude
@@ -1,3 +1,7 @@
 # SC1090 - Can't follow non-constant source. Use a directive to specify location - https://github.com/koalaman/shellcheck/wiki/SC1090
 # SC2034 - Variable appears unused. Verify it or export it - https://github.com/koalaman/shellcheck/wiki/SC2034
 # SC2155 - Declare and assign separately to avoid masking return values - https://github.com/koalaman/shellcheck/wiki/SC2155
+# SC2206 - Quote to prevent word splitting/globbing, or split robustly with mapfile or read -a - https://github.com/koalaman/shellcheck/wiki/SC2206
+# SC2207 - Prefer mapfile or read -a to split command output (or quote to avoid splitting) - https://github.com/koalaman/shellcheck/wiki/SC2207
+# SC2220 - Invalid flags are not handled. Add a *) case - https://github.com/koalaman/shellcheck/wiki/SC2220
+# SC2230 - which is non-standard. Use builtin 'command -v' instead - https://github.com/koalaman/shellcheck/wiki/SC2230
Author	SHA1	Message	Date
Jose Diaz-Gonzalez	74af0482bf	Release 1.12.1	2021-01-17 21:16:14 -05:00
Jose Diaz-Gonzalez	9d318cf26b	fix: do not shadow TMPDIR variable This enables usage of the plugin with libpam-tmpdir. Refs dokku/dokku#3149	2021-01-17 21:02:28 -05:00
Jose Diaz-Gonzalez	a81da2b3ae	Release 1.12.0	2020-09-30 12:49:29 -04:00
Jose Diaz-Gonzalez	b6aec377bc	Merge pull request #97 from fruitl00p/patch-1 Faster exporting for innodb tables	2020-09-30 12:49:03 -04:00
Jose Diaz-Gonzalez	d9d44eea45	fix: correct image link	2020-09-27 12:38:50 -04:00
Robin Speekenbrink	c2e58c773e	Faster exporting for innodb tables Since InnoDB is the standard, i'd like to add the option `--single-transaction --quick` to the mysqldump command. This should speed up larger database exports without tearing the environment up whilst doing so... (see https://dev.mysql.com/doc/refman/5.7/en/mysqldump.html#option_mysqldump_single-transaction) Another way would be to allow for custom config to be loaded which inludes a optional `[mysqldump]` section... Another (even better perhaps) solution would be to have non-s3-backup command that utilizes the i.e. percona xtrabackup as the backup mechanism (and restore) but that changes from simple SQL backups to more advanced full database stuff...	2020-09-25 10:20:32 +02:00
Jose Diaz-Gonzalez	296607be93	Merge pull request #117 from dokku/configurable-config fix: allow config directory to be configurable	2020-05-16 04:52:46 -04:00
Jose Diaz-Gonzalez	49c00a0479	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	2405b7ef22	Release 1.11.5	2020-05-15 00:58:46 -04:00
Jose Diaz-Gonzalez	c1e8c4d774	fix: respect the TMPDIR environment variable Refs dokku/dokku-redis#143	2020-05-15 00:57:21 -04:00
Jose Diaz-Gonzalez	e849268847	Release 1.11.4	2020-05-15 00:53:27 -04:00
Jose Diaz-Gonzalez	9540977fe9	docs: correct help output Refs dokku/dokku-postgres#197	2020-05-15 00:40:24 -04:00
Jose Diaz-Gonzalez	83fa90a012	docs: correct casing/quoting on sentences	2020-05-15 00:34:37 -04:00
Jose Diaz-Gonzalez	c26e54bc11	chore: run black	2020-05-14 23:57:49 -04:00
Jose Diaz-Gonzalez	3a483f1351	docs: document all flags in readme	2020-05-14 23:37:57 -04:00
Jose Diaz-Gonzalez	7e8008e019	docs: make the gpg passphrase a bit more clear	2020-05-14 23:33:01 -04:00
Jose Diaz-Gonzalez	f11f34287a	Release 1.11.3	2020-05-14 22:59:43 -04:00
Jose Diaz-Gonzalez	5e41d13684	chore: update copyright date	2020-05-14 22:57:38 -04:00
Jose Diaz-Gonzalez	f2197fd2a5	docs: switch build shield to circleci	2020-04-05 20:41:00 -04:00
Jose Diaz-Gonzalez	2d6ef274e0	tests: use circleci 2.1	2020-04-05 20:40:20 -04:00
Jose Diaz-Gonzalez	6342be800d	Release 1.11.2	2020-04-04 22:27:46 -04:00
Jose Diaz-Gonzalez	37baaaf0b1	fix: store the correct path	2020-04-04 22:25:11 -04:00
Jose Diaz-Gonzalez	9557f9cc91	Release 1.11.1	2020-04-04 21:50:29 -04:00
Jose Diaz-Gonzalez	e4395e52c4	tests: drop travisci usage	2020-04-04 21:43:59 -04:00
Jose Diaz-Gonzalez	e0cf629712	tests: store test results for usage in circleci	2020-04-04 21:41:43 -04:00
Jose Diaz-Gonzalez	247838d9f8	feat: enable circleci	2020-04-04 21:27:53 -04:00
Jose Diaz-Gonzalez	1aaed290a5	feat: speed up tests by dropping dhparam generation	2020-04-04 21:27:43 -04:00
Jose Diaz-Gonzalez	ff3cd23714	fix: use python3 for generating the readme	2020-04-04 16:47:36 -04:00
Jose Diaz-Gonzalez	1b333b992c	docs: drop unimpemented commands from readme and reorganize	2020-04-04 16:43:31 -04:00
Jose Diaz-Gonzalez	636907f6eb	feat: autogenerate readme from command help	2020-04-04 16:20:35 -04:00
Jose Diaz-Gonzalez	c6ec5b74c5	fix: correct issue where help output for info flag implied multiple flags	2020-04-04 16:18:22 -04:00
Jose Diaz-Gonzalez	3f014b76b8	feat: update shellcheck excludes	2020-04-04 13:38:33 -04:00
Jose Diaz-Gonzalez	78716b46d2	feat: add xunit-reader to output xunit files in human readable format	2020-04-04 13:37:50 -04:00
Jose Diaz-Gonzalez	b21e20679c	feat: parameterize xunit-to-github version	2020-04-04 13:37:03 -04:00
Jose Diaz-Gonzalez	d19c32ce0a	fix: use non-deprecated method of fetching docker-options	2020-04-04 13:36:27 -04:00
Jose Diaz-Gonzalez	28f5f9a88c	feat: upgrade shfmt	2020-04-04 13:35:52 -04:00
Jose Diaz-Gonzalez	7af558a0dd	Release 1.11.0	2020-03-31 01:35:29 -04:00
Jose Diaz-Gonzalez	6dd81c8472	feat: upgrade tertiary container images	2020-03-30 20:12:18 -04:00
Jose Diaz-Gonzalez	3e7269293e	feat: move all image names to config file This allows us to more quickly update the image versions in use for tertiary images.	2020-03-30 20:09:03 -04:00
Jose Diaz-Gonzalez	943f1249f4	feat: add service-specific header to info call	2020-03-20 15:59:03 -04:00
Jose Diaz-Gonzalez	38120ef23d	fix: correct test case for :list command	2020-03-20 14:58:06 -04:00
Jose Diaz-Gonzalez	9e132e7712	fix: ignore the keyfile install for tests	2020-03-20 11:14:27 -04:00
Jose Diaz-Gonzalez	8312c39b40	fix: correct shellcheck issue	2020-03-20 11:05:44 -04:00
Jose Diaz-Gonzalez	562d75e6d7	feat: update travis setup - Use ubuntu bionic - Upgrade tested version of dokku	2020-03-20 10:58:25 -04:00
Jose Diaz-Gonzalez	d6df977b40	Release 1.10.1	2020-03-06 10:20:14 -05:00
Jose Diaz-Gonzalez	b3bd0eed5a	fix: correct service title	2020-03-06 10:19:43 -05:00
Jose Diaz-Gonzalez	b9da3d231a	Release 1.10.0	2020-03-03 16:05:18 -05:00
Jose Diaz-Gonzalez	d191f396bd	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	cf57016c86	fix: speed up service_status by reducing container status calls	2020-03-03 15:57:20 -05:00
Jose Diaz-Gonzalez	489b7db1a6	Release 1.9.5	2019-12-27 16:57:43 -05:00
Jose Diaz-Gonzalez	dc3bb16cfe	chore: update dokku/wait version	2019-12-27 16:57:13 -05:00
Jose Diaz-Gonzalez	51fce5828d	Release 1.9.4	2019-12-27 16:56:04 -05:00
Jose Diaz-Gonzalez	adee49ac1e	chore: update dokku/ambassador version	2019-12-27 16:55:25 -05:00
Jose Diaz-Gonzalez	76e36056b5	Release 1.9.3	2019-12-27 16:54:08 -05:00
Jose Diaz-Gonzalez	98699bf79d	chore: update dokku/s3backup version	2019-12-27 16:53:23 -05:00
Jose Diaz-Gonzalez	f67ccbb3e0	Release 1.9.2	2019-11-22 19:19:04 -05:00
Jose Diaz-Gonzalez	d5004ccb9b	feat: update patch release of mysql	2019-11-22 19:19:01 -05:00
Jose Diaz-Gonzalez	fa0f26d466	Release 1.9.1	2019-09-19 15:17:34 -04:00
Jose Diaz-Gonzalez	7fbf25ef2b	fix: install updated gpg key and nginx apt repository	2019-09-19 13:30:46 -04:00
Jose Diaz-Gonzalez	d3a8821897	fix: add missing ampersands	2019-07-30 10:51:51 -04:00
Jose Diaz-Gonzalez	56c918342f	chore: create scripts directory as necessary	2019-07-30 10:46:00 -04:00
Jose Diaz-Gonzalez	6c18d6740e	feat: skip subcommand copy if no subcommands directory exists	2019-07-29 22:03:01 -04:00
Jose Diaz-Gonzalez	7adb4a9a04	Release 1.9.0	2019-07-15 15:00:27 -07:00
Jose Diaz-Gonzalez	925fb8597e	feat: add service:links command This allows users to script against apps that are linked to a given service	2019-07-15 14:59:05 -07:00
Jose Diaz-Gonzalez	9b88cde4c0	Merge pull request #112 from dokku/upgrade-version Upgrade docker image versions	2019-07-15 14:17:56 -07:00
Jose Diaz-Gonzalez	0fca2b6ee0	chore: increase vm.max_map_count This is mainly used for elasticsearch but adding it to the generic test suite for all datastore plugins makes it easier to copy the travis config to each plugin.	2019-07-12 13:43:57 -07:00
Jose Diaz-Gonzalez	26084da79a	fix: use correct variable for checking for password file	2019-07-12 12:56:37 -07:00
Jose Diaz-Gonzalez	6418fa4474	chore: update build targets	2019-07-11 16:35:06 -07:00
Jose Diaz-Gonzalez	c585944582	chore: move to helper functions for fetching passwords	2019-07-11 16:34:35 -07:00
Jose Diaz-Gonzalez	3b9255bf85	chore: reorder images	2019-07-11 14:32:49 -07:00
Jose Diaz-Gonzalez	3c28a9f2a7	feat: update ambassador, s3backup, and wait images	2019-07-11 14:31:47 -07:00
Jose Diaz-Gonzalez	c5a6f4fc37	feat: upgrade busybox to 1.31.0-uclibc	2019-07-11 13:36:41 -07:00
Jose Diaz-Gonzalez	70fb9d8d1d	feat: upgrade to 5.7.26	2019-07-11 13:24:12 -07:00