Release 1.11.3

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

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

.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

LICENSE.txt

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

Makefile

@@ -1,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

README.md

@@ -1,87 +1,106 @@
-# dokku mongo [![Build Status](https://img.shields.io/travis/dokku/dokku-mongo.svg?branch=master "Build Status")](https://travis-ci.org/dokku/dokku-mongo) [![IRC Network](https://img.shields.io/badge/irc-freenode-blue.svg "IRC Freenode")](https://webchat.freenode.net/?channels=dokku)
+# dokku mongo [![Build Status](https://img.shields.io/circleci/project/github/dokku/dokku-mongo.svg?branch=master&style=flat-square "Build Status")](https://circleci.com/gh/dokku/dokku-mongo/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 mongo plugin for dokku. Currently defaults to installing [mongo 3.6.15](https://hub.docker.com/_/mongo/).
 
-## 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-mongo.git mongo
 ```
 
-## commands
+## Commands
 
 ```
-mongo:app-links <app>          List all mongo service links for a given app
+mongo:app-links <app>                              # list all mongo service links for a given app
-mongo:backup <name> <bucket> (--use-iam) Create a backup of the mongo service to an existing s3 bucket
+mongo:backup <service> <bucket-name> [--use-iam]   # creates a backup of the mongo service to an existing s3 bucket
-mongo:backup-auth <name> <aws_access_key_id> <aws_secret_access_key> (<aws_default_region>) (<aws_signature_version>) (<endpoint_url>) Sets up authentication for backups on the mongo service
+mongo:backup-auth <service> <aws-access-key-id> <aws-secret-access-key> <aws-default-region> <aws-signature-version> <endpoint-url> # sets up authentication for backups on the mongo service
-mongo:backup-deauth <name>     Removes backup authentication for the mongo service
+mongo:backup-deauth <service>                      # removes backup authentication for the mongo service
-mongo:backup-schedule <name> <schedule> <bucket> Schedules a backup of the mongo service
+mongo:backup-schedule <service> <schedule> <bucket-name> [--use-iam] # schedules a backup of the mongo service
-mongo:backup-schedule-cat <name> Cat the contents of the configured backup cronfile for the service
+mongo:backup-schedule-cat <service>                # cat the contents of the configured backup cronfile for the service
-mongo:backup-set-encryption <name> <passphrase> Set a GPG passphrase for backups
+mongo:backup-set-encryption <service> <passphrase> # sets encryption for all future backups of mongo service
-mongo:backup-unschedule <name> Unschedules the backup of the mongo service
+mongo:backup-unschedule <service>                  # unschedules the backup of the mongo service
-mongo:backup-unset-encryption <name> Removes backup encryption for future backups of the mongo service
+mongo:backup-unset-encryption <service>            # unsets encryption for future backups of the mongo service
-mongo:clone <name> <new-name>  Create container <new-name> then copy data from <name> into <new-name>
+mongo:clone <service> <new-service> [--clone-flags...] # create container <new-name> then copy data from <name> into <new-name>
-mongo:connect <name>           Connect via telnet to a mongo service
+mongo:connect <service>                            # connect to the service via the mongo connection tool
-mongo:connect-admin <name>     Connect via telnet to a mongo service as admin user
+mongo:connect-admin <service>                      # connect via mongo to a mongo service as admin user
-mongo:create <name>            Create a mongo service with environment variables
+mongo:create <service> [--create-flags...]         # create a mongo service
-mongo:destroy <name>           Delete the service, delete the data and stop its container if there are no links left
+mongo:destroy <service> [-f|--force]               # delete the mongo service/data/container if there are no links left
-mongo:enter <name> [command]   Enter or run a command in a running mongo service container
+mongo:enter <service>                              # enter or run a command in a running mongo service container
-mongo:exists <service>         Check if the mongo service exists
+mongo:exists <service>                             # check if the mongo service exists
-mongo:export <name> > <file>   Export a dump of the mongo service database (as gzipped archive file)
+mongo:export <service>                             # export a dump of the mongo service database
-mongo:expose <name> [port]     Expose a mongo service on custom port if provided (random port otherwise)
+mongo:expose <service> <ports...>                  # expose a mongo service on custom port if provided (random port otherwise)
-mongo:import <name> < <file>   Import a dump into the mongo service database
+mongo:import <service>                             # import a dump into the mongo service database
-mongo:info <name>              Print the connection information
+mongo:info <service> [--single-info-flag]          # print the service information
-mongo:link <name> <app>        Link the mongo service to the app
+mongo:link <service> <app> [--link-flags...]       # link the mongo service to the app
-mongo:linked <name> <app>      Check if the mongo service is linked to an app
+mongo:linked <service> <app>                       # check if the mongo service is linked to an app
-mongo:list                     List all mongo services
+mongo:links <service>                              # list all apps linked to the mongo service
-mongo:logs <name> [-t]         Print the most recent log(s) for this service
+mongo:list                                         # list all mongo services
-mongo:promote <name> <app>     Promote service <name> as MONGO_URL in <app>
+mongo:logs <service> [-t|--tail]                   # print the most recent log(s) for this service
-mongo:restart <name>           Graceful shutdown and restart of the mongo service container
+mongo:promote <service> <app>                      # promote service <service> as MONGO_URL in <app>
-mongo:start <name>             Start a previously stopped mongo service
+mongo:restart <service>                            # graceful shutdown and restart of the mongo service container
-mongo:stop <name>              Stop a running mongo service
+mongo:start <service>                              # start a previously stopped mongo service
-mongo:unexpose <name>          Unexpose a previously exposed mongo service
+mongo:stop <service>                               # stop a running mongo service
-mongo:unlink <name> <app>      Unlink the mongo service from the app
+mongo:unexpose <service>                           # unexpose a previously exposed mongo service
-mongo:upgrade <name>           Upgrade service <service> to the specified version
+mongo:unlink <service> <app>                       # unlink the mongo service from the app
+mongo:upgrade <service> [--upgrade-flags...]       # upgrade service <service> to the specified versions
 ```
 
-## usage
+## Usage
+
+Help for any commands can be displayed by specifying the command as an argument to mongo:help. Please consult the `mongo:help` command for any undocumented commands.
+
+### Basic Usage
+
+### create a mongo service
 
 ```shell
-# create a mongo service named lolipop
+# usage
-dokku mongo:create lolipop
+dokku mongo:create <service> [--create-flags...]
+```
 
-# you can also specify the image and image
+Create a mongo service named lolipop:
-# version to use for the service
-# it *must* be compatible with the
-# official mongo image
-export MONGO_IMAGE="mongo"
-export MONGO_IMAGE_VERSION="3.0.5"
-dokku mongo:create lolipop
 
-# you can also specify custom environment
+```shell
-# variables to start the mongo service
+dokku mongo:create lolipop
-# in semi-colon separated form
+```
+
+You can also specify the image and image version to use for the service. It *must* be compatible with the ${plugin_image} image.
+
+```shell
+export MONGO_IMAGE="${PLUGIN_IMAGE}"
+export MONGO_IMAGE_VERSION="${PLUGIN_IMAGE_VERSION}"
+dokku mongo:create lolipop
+```
+
+You can also specify custom environment variables to start the mongo service in semi-colon separated form.
+
+```shell
 export MONGO_CUSTOM_ENV="USER=alpha;HOST=beta"
 dokku mongo:create lolipop
+```
 
-# by default we use the wiredTiger storage solution
+### print the service information
-# if you are using an image version less than 3.x
-# you will need to set a custom MONGO_CONFIG_OPTIONS
-# environment variable
-export MONGO_CONFIG_OPTIONS=" --auth "
-export MONGO_IMAGE_VERSION="2.6.11"
-dokku mongo:create lolipop
 
-# get connection information as follows
+```shell
+# usage
+dokku mongo:info <service> [--single-info-flag]
+```
+
+Get connection information as follows:
+
+```shell
 dokku mongo:info lolipop
+```
 
-# you can also retrieve a specific piece of service info via flags
+You can also retrieve a specific piece of service info via flags:
+
+```shell
 dokku mongo:info lolipop --config-dir
 dokku mongo:info lolipop --data-dir
 dokku mongo:info lolipop --dsn
@@ -92,153 +111,494 @@ dokku mongo:info lolipop --links
 dokku mongo:info lolipop --service-root
 dokku mongo:info lolipop --status
 dokku mongo:info lolipop --version
+```
 
-# a bash prompt can be opened against a running service
+### list all mongo services
-# filesystem changes will not be saved to disk
-dokku mongo:enter lolipop
 
-# you may also run a command directly against the service
+```shell
-# filesystem changes will not be saved to disk
+# usage
-dokku mongo:enter lolipop ls -lah /
+dokku mongo:list 
+```
 
-# a mongo service can be linked to a
+List all services:
-# container this will use native docker
-# links via the docker-options plugin
-# here we link it to our 'playground' app
-# NOTE: this will restart your app
-dokku mongo:link lolipop playground
 
-# the following environment variables will be set automatically by docker (not
+```shell
-# on the app itself, so they won’t be listed when calling dokku config)
+dokku mongo:list
-#
+```
-#   DOKKU_MONGO_LOLIPOP_NAME=/lolipop/DATABASE
-#   DOKKU_MONGO_LOLIPOP_PORT=tcp://172.17.0.1:27017
-#   DOKKU_MONGO_LOLIPOP_PORT_27017_TCP=tcp://172.17.0.1:27017
-#   DOKKU_MONGO_LOLIPOP_PORT_27017_TCP_PROTO=tcp
-#   DOKKU_MONGO_LOLIPOP_PORT_27017_TCP_PORT=27017
-#   DOKKU_MONGO_LOLIPOP_PORT_27017_TCP_ADDR=172.17.0.1
-#
-# and the following will be set on the linked application by default
-#
-#   MONGO_URL=mongodb://lolipop:SOME_PASSWORD@dokku-mongo-lolipop:27017/lolipop
-#
-# NOTE: the host exposed here only works internally in docker containers. If
-# you want your container to be reachable from outside, you should use `expose`.
 
-# another service can be linked to your app
+### print the most recent log(s) for this service
-dokku mongo:link other_service playground
 
-# since DATABASE_URL is already in use, another environment variable will be
+```shell
-# generated automatically
+# usage
-#
+dokku mongo:logs <service> [-t|--tail]
-#   DOKKU_MONGO_BLUE_URL=mongodb://other_service:ANOTHER_PASSWORD@dokku-mongo-other-service:27017/other_service
+```
 
-# you can then promote the new service to be the primary one
+You can tail logs for a particular service:
-# NOTE: this will restart your app
-dokku mongo:promote other_service playground
 
-# this will replace MONGO_URL with the url from other_service and generate
+```shell
-# another environment variable to hold the previous value if necessary.
-# you could end up with the following for example:
-#
-#   MONGO_URL=mongodb://other_service:ANOTHER_PASSWORD@dokku-mongo-other-service:27017/other_service
-#   DOKKU_MONGO_BLUE_URL=mongodb://other_service:ANOTHER_PASSWORD@dokku-mongo-other-service:27017/other_service
-#   DOKKU_MONGO_SILVER_URL=mongodb://lolipop:SOME_PASSWORD@dokku-mongo-lolipop:27017/lolipop
-
-# you can also unlink a mongo service
-# NOTE: this will restart your app and unset related environment variables
-dokku mongo:unlink lolipop playground
-
-# you can tail logs for a particular service
 dokku mongo:logs lolipop
-dokku mongo:logs lolipop -t # to tail
-
-# you can dump the database
-dokku mongo:export lolipop > lolipop.dump.gz
-
-# you can import a dump
-dokku mongo:import lolipop < database.dump.gz
-
-# you can clone an existing database to a new one
-dokku mongo:clone lolipop new_database
-
-# finally, you can destroy the container
-dokku mongo:destroy lolipop
 ```
 
-## Changing database adapter
+By default, logs will not be tailed, but you can do this with the --tail flag:
-
-It's possible to change the protocol for MONGO_URL by setting
-the environment variable MONGO_DATABASE_SCHEME on the app:
 
+```shell
+dokku mongo:logs lolipop --tail
 ```
-dokku config:set playground MONGO_DATABASE_SCHEME=mongo2
+
+### link the mongo service to the app
+
+```shell
+# usage
+dokku mongo:link <service> <app> [--link-flags...]
+```
+
+A mongo service can be linked to a container. This will use native docker links via the docker-options plugin. Here we link it to our 'playground' app.
+
+> NOTE: this will restart your app
+
+```shell
 dokku mongo:link lolipop playground
 ```
 
-Will cause MONGO_URL to be set as
+The following environment variables will be set automatically by docker (not on the app itself, so they won’t be listed when calling dokku config):
-mongo2://lolipop:SOME_PASSWORD@dokku-mongo-lolipop:27017/lolipop
 
-CAUTION: Changing MONGO_DATABASE_SCHEME after linking will cause dokku to
+```
-believe the mongo is not linked when attempting to use `dokku mongo:unlink`
+DOKKU_MONGO_LOLIPOP_NAME=/lolipop/DATABASE
-or `dokku mongo:promote`.
+DOKKU_MONGO_LOLIPOP_PORT=tcp://172.17.0.1:27017
-You should be able to fix this by
+DOKKU_MONGO_LOLIPOP_PORT_27017_TCP=tcp://172.17.0.1:27017
+DOKKU_MONGO_LOLIPOP_PORT_27017_TCP_PROTO=tcp
+DOKKU_MONGO_LOLIPOP_PORT_27017_TCP_PORT=27017
+DOKKU_MONGO_LOLIPOP_PORT_27017_TCP_ADDR=172.17.0.1
+```
 
-- Changing MONGO_URL manually to the new value.
+The following will be set on the linked application by default:
 
-OR
+```
+MONGO_URL=mongodb://lolipop:SOME_PASSWORD@dokku-mongo-lolipop:27017/lolipop
+```
 
-- Set MONGO_DATABASE_SCHEME back to its original setting
+The host exposed here only works internally in docker containers. If you want your container to be reachable from outside, you should use the 'expose' subcommand. Another service can be linked to your app:
-- Unlink the service
-- Change MONGO_DATABASE_SCHEME to the desired setting
-- Relink the service
 
-## Backups
+```shell
+dokku mongo:link other_service playground
+```
+
+It is possible to change the protocol for mongo_url by setting the environment variable mongo_database_scheme on the app. Doing so will after linking will cause the plugin to think the service is not linked, and we advise you to unlink before proceeding.
+
+```shell
+dokku config:set playground MONGO_DATABASE_SCHEME=mongodb2
+dokku mongo:link lolipop playground
+```
+
+This will cause mongo_url to be set as:
+
+```
+mongodb2://lolipop:SOME_PASSWORD@dokku-mongo-lolipop:27017/lolipop
+```
+
+### unlink the mongo service from the app
+
+```shell
+# usage
+dokku mongo:unlink <service> <app>
+```
+
+You can unlink a mongo service:
+
+> NOTE: this will restart your app and unset related environment variables
+
+```shell
+dokku mongo:unlink lolipop playground
+```
+
+### Service Lifecycle
+
+The lifecycle of each service can be managed through the following commands:
+
+### connect to the service via the mongo connection tool
+
+```shell
+# usage
+dokku mongo:connect <service>
+```
+
+Connect to the service via the mongo connection tool:
+
+```shell
+dokku mongo:connect lolipop
+```
+
+### enter or run a command in a running mongo service container
+
+```shell
+# usage
+dokku mongo:enter <service>
+```
+
+A bash prompt can be opened against a running service. Filesystem changes will not be saved to disk.
+
+```shell
+dokku mongo:enter lolipop
+```
+
+You may also run a command directly against the service. Filesystem changes will not be saved to disk.
+
+```shell
+dokku mongo:enter lolipop touch /tmp/test
+```
+
+### expose a mongo service on custom port if provided (random port otherwise)
+
+```shell
+# usage
+dokku mongo:expose <service> <ports...>
+```
+
+Expose the service on the service's normal ports, allowing access to it from the public interface (0. 0. 0. 0):
+
+```shell
+dokku mongo:expose lolipop ${PLUGIN_DATASTORE_PORTS[@]}
+```
+
+### unexpose a previously exposed mongo service
+
+```shell
+# usage
+dokku mongo:unexpose <service>
+```
+
+Unexpose the service, removing access to it from the public interface (0. 0. 0. 0):
+
+```shell
+dokku mongo:unexpose lolipop
+```
+
+### promote service <service> as MONGO_URL in <app>
+
+```shell
+# usage
+dokku mongo:promote <service> <app>
+```
+
+If you have a mongo service linked to an app and try to link another mongo service another link environment variable will be generated automatically:
+
+```
+DOKKU_MONGO_BLUE_URL=mongodb://other_service:ANOTHER_PASSWORD@dokku-mongo-other-service:27017/other_service
+```
+
+You can promote the new service to be the primary one:
+
+> NOTE: this will restart your app
+
+```shell
+dokku mongo:promote other_service playground
+```
+
+This will replace mongo_url with the url from other_service and generate another environment variable to hold the previous value if necessary. You could end up with the following for example:
+
+```
+MONGO_URL=mongodb://other_service:ANOTHER_PASSWORD@dokku-mongo-other-service:27017/other_service
+DOKKU_MONGO_BLUE_URL=mongodb://other_service:ANOTHER_PASSWORD@dokku-mongo-other-service:27017/other_service
+DOKKU_MONGO_SILVER_URL=mongodb://lolipop:SOME_PASSWORD@dokku-mongo-lolipop:27017/lolipop
+```
+
+### start a previously stopped mongo service
+
+```shell
+# usage
+dokku mongo:start <service>
+```
+
+Start the service:
+
+```shell
+dokku mongo:start lolipop
+```
+
+### stop a running mongo service
+
+```shell
+# usage
+dokku mongo:stop <service>
+```
+
+Stop the service and the running container:
+
+```shell
+dokku mongo:stop lolipop
+```
+
+### graceful shutdown and restart of the mongo service container
+
+```shell
+# usage
+dokku mongo:restart <service>
+```
+
+Restart the service:
+
+```shell
+dokku mongo:restart lolipop
+```
+
+### upgrade service <service> to the specified versions
+
+```shell
+# usage
+dokku mongo:upgrade <service> [--upgrade-flags...]
+```
+
+You can upgrade an existing service to a new image or image-version:
+
+```shell
+dokku mongo:upgrade lolipop
+```
+
+### Service Automation
+
+Service scripting can be executed using the following commands:
+
+### list all mongo service links for a given app
+
+```shell
+# usage
+dokku mongo:app-links <app>
+```
+
+List all mongo services that are linked to the 'playground' app.
+
+```shell
+dokku mongo:app-links playground
+```
+
+### create container <new-name> then copy data from <name> into <new-name>
+
+```shell
+# usage
+dokku mongo:clone <service> <new-service> [--clone-flags...]
+```
+
+You can clone an existing service to a new one:
+
+```shell
+dokku mongo:clone lolipop lolipop-2
+```
+
+### check if the mongo service exists
+
+```shell
+# usage
+dokku mongo:exists <service>
+```
+
+Here we check if the lolipop mongo service exists.
+
+```shell
+dokku mongo:exists lolipop
+```
+
+### check if the mongo service is linked to an app
+
+```shell
+# usage
+dokku mongo:linked <service> <app>
+```
+
+Here we check if the lolipop mongo service is linked to the 'playground' app.
+
+```shell
+dokku mongo:linked lolipop playground
+```
+
+### list all apps linked to the mongo service
+
+```shell
+# usage
+dokku mongo:links <service>
+```
+
+List all apps linked to the 'lolipop' mongo service.
+
+```shell
+dokku mongo:links lolipop
+```
+
+### Data Management
+
+The underlying service data can be imported and exported with the following commands:
+
+### import a dump into the mongo service database
+
+```shell
+# usage
+dokku mongo:import <service>
+```
+
+Import a datastore dump:
+
+```shell
+dokku mongo:import lolipop < database.dump
+```
+
+### export a dump of the mongo service database
+
+```shell
+# usage
+dokku mongo:export <service>
+```
+
+By default, datastore output is exported to stdout:
+
+```shell
+dokku mongo:export lolipop
+```
+
+You can redirect this output to a file:
+
+```shell
+dokku mongo:export lolipop > lolipop.dump
+```
+
+### Backups
 
 Datastore backups are supported via AWS S3 and S3 compatible services like [minio](https://github.com/minio/minio).
 
-You may skip the `backup-auth` step if your dokku install is running within EC2
+You may skip the `backup-auth` step if your dokku install is running within EC2 and has access to the bucket via an IAM profile. In that case, use the `--use-iam` option with the `backup` command.
-and has access to the bucket via an IAM profile. In that case, use the `--use-iam`
-option with the `backup` command.
 
 Backups can be performed using the backup commands:
 
+### sets up authentication for backups on the mongo service
+
+```shell
+# usage
+dokku mongo:backup-auth <service> <aws-access-key-id> <aws-secret-access-key> <aws-default-region> <aws-signature-version> <endpoint-url>
 ```
-# setup s3 backup authentication
+
+Setup s3 backup authentication:
+
+```shell
 dokku mongo:backup-auth lolipop AWS_ACCESS_KEY_ID AWS_SECRET_ACCESS_KEY
-
-# remove s3 authentication
-dokku mongo:backup-deauth lolipop
-
-# backup the `lolipop` service to the `BUCKET_NAME` bucket on AWS
-dokku mongo:backup lolipop BUCKET_NAME
-
-# schedule a backup
-# CRON_SCHEDULE is a crontab expression, eg. "0 3 * * *" for each day at 3am
-dokku mongo:backup-schedule lolipop CRON_SCHEDULE BUCKET_NAME
-
-# cat the contents of the configured backup cronfile for the service
-dokku mongo:backup-schedule-cat lolipop
-
-# remove the scheduled backup from cron
-dokku mongo:backup-unschedule lolipop
 ```
 
-Backup auth can also be set up for different regions, signature versions and endpoints (e.g. for minio):
+Setup s3 backup authentication with different region:
- 
+
-```
+```shell
-# setup s3 backup authentication with different region
 dokku mongo:backup-auth lolipop AWS_ACCESS_KEY_ID AWS_SECRET_ACCESS_KEY AWS_REGION
- 
+```
-# setup s3 backup authentication with different signature version and endpoint
+
+Setup s3 backup authentication with different signature version and endpoint:
+
+```shell
 dokku mongo:backup-auth lolipop AWS_ACCESS_KEY_ID AWS_SECRET_ACCESS_KEY AWS_REGION AWS_SIGNATURE_VERSION ENDPOINT_URL
- 
+```
-# more specific example for minio auth
+
+More specific example for minio auth:
+
+```shell
 dokku mongo:backup-auth lolipop MINIO_ACCESS_KEY_ID MINIO_SECRET_ACCESS_KEY us-east-1 s3v4 https://YOURMINIOSERVICE
 ```
 
-## Disabling `docker pull` calls
+### removes backup authentication for the mongo service
+
+```shell
+# usage
+dokku mongo:backup-deauth <service>
+```
+
+Remove s3 authentication:
+
+```shell
+dokku mongo:backup-deauth lolipop
+```
+
+### creates a backup of the mongo service to an existing s3 bucket
+
+```shell
+# usage
+dokku mongo:backup <service> <bucket-name> [--use-iam]
+```
+
+Backup the 'lolipop' service to the 'my-s3-bucket' bucket on aws:
+
+```shell
+dokku mongo:backup lolipop my-s3-bucket --use-iam
+```
+
+### sets encryption for all future backups of mongo service
+
+```shell
+# usage
+dokku mongo:backup-set-encryption <service> <passphrase>
+```
+
+Set a gpg passphrase for backups:
+
+```shell
+dokku mongo:backup-set-encryption lolipop
+```
+
+### unsets encryption for future backups of the mongo service
+
+```shell
+# usage
+dokku mongo:backup-unset-encryption <service>
+```
+
+Unset a gpg encryption key for backups:
+
+```shell
+dokku mongo:backup-unset-encryption lolipop
+```
+
+### schedules a backup of the mongo service
+
+```shell
+# usage
+dokku mongo:backup-schedule <service> <schedule> <bucket-name> [--use-iam]
+```
+
+Schedule a backup:
+
+> 'schedule' is a crontab expression, eg. "0 3 * * *" for each day at 3am
+
+```shell
+dokku mongo:backup-schedule lolipop "0 3 * * *" my-s3-bucket
+```
+
+Schedule a backup and authenticate via iam:
+
+```shell
+dokku mongo:backup-schedule lolipop "0 3 * * *" my-s3-bucket --use-iam
+```
+
+### cat the contents of the configured backup cronfile for the service
+
+```shell
+# usage
+dokku mongo:backup-schedule-cat <service>
+```
+
+Cat the contents of the configured backup cronfile for the service:
+
+```shell
+dokku mongo:backup-schedule-cat lolipop
+```
+
+### unschedules the backup of the mongo service
+
+```shell
+# usage
+dokku mongo:backup-unschedule <service>
+```
+
+Remove the scheduled backup from cron:
+
+```shell
+dokku mongo:backup-unschedule lolipop
+```
+
+### Disabling `docker pull` calls
 
 If you wish to disable the `docker pull` calls that the plugin triggers, you may set the `MONGO_DISABLE_PULL` environment variable to `true`. Once disabled, you will need to pull the service image you wish to deploy as shown in the `stderr` output.
 
-Please ensure the proper images are in place when `docker pull` is disabled.
+Please ensure the proper images are in place when `docker pull` is disabled.

bin/generate

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

common-functions

@@ -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"
@@ -217,7 +218,7 @@ service_backup() {
   fi
 
   # shellcheck disable=SC2086
-  docker run --rm $BACKUP_PARAMETERS dokku/s3backup:0.10.1
+  docker run --rm $BACKUP_PARAMETERS "$PLUGIN_S3BACKUP_IMAGE"
 }
 
 service_backup_auth() {
@@ -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#*: }")"
@@ -500,7 +501,7 @@ service_list() {
     return
   fi
 
-  dokku_log_info2_quiet "Postgres services"
+  dokku_log_info2_quiet "$PLUGIN_SERVICE services"
   for SERVICE in $SERVICES; do
     echo "$SERVICE"
   done
@@ -686,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.3.1 >/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

config

@@ -26,3 +26,8 @@ if [[ -n $DOKKU_API_VERSION ]]; then
 fi
 
 export MONGO_CONFIG_OPTIONS=${MONGO_CONFIG_OPTIONS:=" --storageEngine wiredTiger --auth "}
+
+export PLUGIN_BUSYBOX_IMAGE="busybox:1.31.1-uclibc"
+export PLUGIN_AMBASSADOR_IMAGE="dokku/ambassador:0.3.3"
+export PLUGIN_S3BACKUP_IMAGE="dokku/s3backup:0.10.3"
+export PLUGIN_WAIT_IMAGE="dokku/wait:0.4.3"

functions

@@ -96,7 +96,7 @@ service_create_container() {
   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.1 -p "$PLUGIN_DATASTORE_WAIT_PORT" >/dev/null
+  docker run --rm --link "$SERVICE_NAME:$PLUGIN_COMMAND_PREFIX" "$PLUGIN_WAIT_IMAGE" -p "$PLUGIN_DATASTORE_WAIT_PORT" >/dev/null
 
   echo "db.createUser({user:'admin',pwd:'$ROOTPASSWORD',roles:[{role:'userAdminAnyDatabase',db:'admin'},{role:'__system',db:'admin'},{role:'root',db:'admin'}]})" | docker exec -i "$SERVICE_NAME" mongo admin >/dev/null
   echo "db.createUser({user:'$SERVICE',pwd:'$PASSWORD',roles:[{role:'readWrite',db:'$DATABASE_NAME'}]})" | docker exec -i "$SERVICE_NAME" mongo -u admin -p "$ROOTPASSWORD" --authenticationDatabase admin "$DATABASE_NAME" >/dev/null

help-functions

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

install

@@ -17,10 +17,10 @@ plugin-install() {
   }
 
   pull-docker-image "${PLUGIN_IMAGE}:${PLUGIN_IMAGE_VERSION}"
-  pull-docker-image "busybox:1.31.0-uclibc"
+  pull-docker-image "$PLUGIN_BUSYBOX_IMAGE"
-  pull-docker-image "dokku/ambassador:0.3.1"
+  pull-docker-image "$PLUGIN_AMBASSADOR_IMAGE"
-  pull-docker-image "dokku/s3backup:0.10.1"
+  pull-docker-image "$PLUGIN_S3BACKUP_IMAGE"
-  pull-docker-image "dokku/wait:0.4.1"
+  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"

plugin.toml

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

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.31.0-uclibc chmod 777 -R /config /data
+  docker run --rm -v "$SERVICE_HOST_ROOT/data:/data" -v "$SERVICE_HOST_ROOT/config:/config" "$PLUGIN_BUSYBOX_IMAGE" chmod 777 -R /config /data
   rm -rf "$SERVICE_ROOT"
 
   dokku_log_info2 "$PLUGIN_SERVICE container deleted: $SERVICE"

subcommands/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"

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.mongo.l:dokku-mongo-l"
   assert_success
   dokku "$PLUGIN_COMMAND_PREFIX:unlink" l my_app

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"
+  run dokku --quiet "$PLUGIN_COMMAND_PREFIX:list"
-  assert_contains "${lines[*]}" "l     mongo:3.6.15  running  -              -"
+  assert_output "l"
-}
-
-@test "($PLUGIN_COMMAND_PREFIX:list) with exposed ports" {
-  dokku "$PLUGIN_COMMAND_PREFIX:expose" l 4242 4243 4244 4245
-  run dokku "$PLUGIN_COMMAND_PREFIX:list"
-  assert_contains "${lines[*]}" "l     mongo:3.6.15  running  27017->4242 27018->4243 27019->4244 28017->4245   -"
-}
-
-@test "($PLUGIN_COMMAND_PREFIX:list) with linked app" {
-  dokku apps:create my_app
-  dokku "$PLUGIN_COMMAND_PREFIX:link" l my_app
-  run dokku "$PLUGIN_COMMAND_PREFIX:list"
-  assert_contains "${lines[*]}" "l     mongo:3.6.15  running  -              my_app"
-  dokku --force apps:destroy my_app
 }
 
 @test "($PLUGIN_COMMAND_PREFIX:list) when there are no services" {
   dokku --force "$PLUGIN_COMMAND_PREFIX:destroy" l
   run dokku "$PLUGIN_COMMAND_PREFIX:list"
-  assert_contains "${lines[*]}" "There are no MongoDB services"
+  assert_output "${lines[*]}" "There are no $PLUGIN_SERVICE services"
   dokku "$PLUGIN_COMMAND_PREFIX:create" l
 }

tests/setup.sh

@@ -2,9 +2,13 @@
 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
+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

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