更新 Dockerfile

chore(deps): bump softprops/action-gh-release from 2.4.0 to 2.4.1

.devcontainer/20_init_plugin

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

.devcontainer/Dockerfile

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

.devcontainer/bin/copy-file

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

.devcontainer/devcontainer.json

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

.github/dependabot.yml

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

.github/workflows/ci.yml

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

.github/workflows/tagged-release.yml

@@ -0,0 +1,20 @@
+---
+name: "tagged-release"
+
+# yamllint disable-line rule:truthy
+on:
+  push:
+    tags:
+      - "*"
+
+jobs:
+  tagged-release:
+    name: tagged-release
+    runs-on: ubuntu-24.04
+
+    steps:
+      - name: Release
+        uses: softprops/action-gh-release@v2.4.1
+        with:
+          generate_release_notes: true
+          make_latest: "true"

.gitignore

@@ -1,2 +1,3 @@
 /tmp
 .vagrant
+bootstrap.sh

.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

Dockerfile

@@ -0,0 +1 @@
+FROM mirror.ccs.tencentyun.com/library/mongo:8.0.15

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,10 @@
 HARDWARE = $(shell uname -m)
 SYSTEM_NAME  = $(shell uname -s | tr '[:upper:]' '[:lower:]')
+ARCH = $(shell dpkg --print-architecture)
+SHFMT_VERSION = 3.0.2
+XUNIT_TO_GITHUB_VERSION = 0.3.0
+XUNIT_READER_VERSION = 0.1.0
+
 
 bats:
 ifeq ($(SYSTEM_NAME),darwin)
@@ -7,7 +12,7 @@ ifneq ($(shell bats --version >/dev/null 2>&1 ; echo $$?),0)
 	brew install bats-core
 endif
 else
-	git clone https://github.com/josegonzalez/bats-core.git /tmp/bats
+	git clone https://github.com/bats-core/bats-core.git /tmp/bats
 	cd /tmp/bats && sudo ./install.sh /usr/local
 	rm -rf /tmp/bats
 endif
@@ -17,7 +22,11 @@ ifneq ($(shell shellcheck --version >/dev/null 2>&1 ; echo $$?),0)
 ifeq ($(SYSTEM_NAME),darwin)
 	brew install shellcheck
 else
-	sudo add-apt-repository 'deb http://archive.ubuntu.com/ubuntu trusty-backports main restricted universe multiverse'
+ifeq ($(ARCH),arm64)
+  sudo add-apt-repository 'deb http://ports.ubuntu.com/ubuntu-ports jammy-backports main restricted universe multiverse'
+else
+  sudo add-apt-repository 'deb http://archive.ubuntu.com/ubuntu jammy-backports main restricted universe multiverse'
+endif
 	sudo rm -rf /var/lib/apt/lists/* && sudo apt-get clean
 	sudo apt-get update -qq && sudo apt-get install -qq -y shellcheck
 endif
@@ -28,7 +37,7 @@ ifneq ($(shell shfmt --version >/dev/null 2>&1 ; echo $$?),0)
 ifeq ($(shfmt),Darwin)
 	brew install shfmt
 else
-	wget -qO /tmp/shfmt https://github.com/mvdan/sh/releases/download/v2.6.2/shfmt_v2.6.2_linux_amd64
+	wget -qO /tmp/shfmt https://github.com/mvdan/sh/releases/download/v$(SHFMT_VERSION)/shfmt_v$(SHFMT_VERSION)_linux_amd64
 	chmod +x /tmp/shfmt
 	sudo mv /tmp/shfmt /usr/local/bin/shfmt
 endif
@@ -59,13 +68,13 @@ unit-tests:
 	@echo running unit tests...
 	@mkdir -p tmp/test-results/bats
 	@cd tests && echo "executing tests: $(shell cd tests ; ls *.bats | xargs)"
-	cd tests && bats --formatter bats-format-junit -e -T -o ../tmp/test-results/bats *.bats
+	cd tests && bats --report-formatter junit --timing -o ../tmp/test-results/bats *.bats
 
-tmp/xunit-to-github:
+tmp/xunit-reader:
 	mkdir -p tmp
-	curl -o tmp/xunit-to-github.tgz -sL https://github.com/josegonzalez/go-xunit-to-github/releases/download/v0.3.0/xunit-to-github_0.3.0_$(SYSTEM_NAME)_$(HARDWARE).tgz
-	tar xf tmp/xunit-to-github.tgz -C tmp
-	chmod +x tmp/xunit-to-github
+	curl -o tmp/xunit-reader.tgz -sL https://github.com/josegonzalez/go-xunit-reader/releases/download/v$(XUNIT_READER_VERSION)/xunit-reader_$(XUNIT_READER_VERSION)_$(SYSTEM_NAME)_$(HARDWARE).tgz
+	tar xf tmp/xunit-reader.tgz -C tmp
+	chmod +x tmp/xunit-reader
 
 setup:
 	bash tests/setup.sh
@@ -73,11 +82,17 @@ setup:
 
 test: lint unit-tests
 
-report: tmp/xunit-to-github
-ifdef TRAVIS_REPO_SLUG
-ifdef GITHUB_ACCESS_TOKEN
-ifneq ($(TRAVIS_PULL_REQUEST),false)
-	tmp/xunit-to-github --skip-ok --job-url "$(TRAVIS_JOB_WEB_URL)" --pull-request-id "$(TRAVIS_PULL_REQUEST)" --repository-slug "$(TRAVIS_REPO_SLUG)" --title "DOKKU_VERSION=$(DOKKU_VERSION)" tmp/test-results/bats tmp/test-results/shellcheck
-endif
-endif
-endif
+report: tmp/xunit-reader
+	tmp/xunit-reader -p 'tmp/test-results/bats/*.xml'
+	tmp/xunit-reader -p 'tmp/test-results/shellcheck/*.xml'
+
+.PHONY: clean
+clean:
+	rm -f README.md
+
+.PHONY: generate
+generate: clean README.md
+
+.PHONY: README.md
+README.md:
+	bin/generate

README.md

@@ -1,244 +1,775 @@
-# 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/github/actions/workflow/status/dokku/dokku-mongo/ci.yml?branch=master&style=flat-square "Build Status")](https://github.com/dokku/dokku-mongo/actions/workflows/ci.yml?query=branch%3Amaster) [![IRC Network](https://img.shields.io/badge/irc-libera-blue.svg?style=flat-square "IRC Libera")](https://webchat.libera.chat/?channels=dokku)
 
-Official mongo plugin for dokku. Currently defaults to installing [mongo 3.6.15](https://hub.docker.com/_/mongo/).
+Official mongo plugin for dokku. Currently defaults to installing [mongo 8.0.15](https://hub.docker.com/_/mongo/).
 
-## requirements
+## Requirements
 
-- dokku 0.12.x+
+- dokku 0.19.x+
 - docker 1.8.x
 
-## installation
+## Installation
 
 ```shell
-# on 0.12.x+
-sudo dokku plugin:install https://github.com/dokku/dokku-mongo.git mongo
+# on 0.19.x+
+sudo dokku plugin:install https://github.com/dokku/dokku-mongo.git --name mongo
 ```
 
-## commands
+## Commands
 
 ```
-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-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-deauth <name>     Removes backup authentication for the mongo service
-mongo:backup-schedule <name> <schedule> <bucket> 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-set-encryption <name> <passphrase> Set a GPG passphrase for backups
-mongo:backup-unschedule <name> Unschedules the backup of the mongo service
-mongo:backup-unset-encryption <name> Removes backup 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:connect <name>           Connect via telnet to a mongo service
-mongo:connect-admin <name>     Connect via telnet to a mongo service as admin user
-mongo:create <name>            Create a mongo service with environment variables
-mongo:destroy <name>           Delete the service, delete the data and stop its container if there are no links left
-mongo:enter <name> [command]   Enter or run a command in a running mongo service container
-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:expose <name> [port]     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:info <name>              Print the connection information
-mongo:link <name> <app>        Link the mongo service to the app
-mongo:linked <name> <app>      Check if the mongo service is linked to an app
-mongo:list                     List all mongo services
-mongo:logs <name> [-t]         Print the most recent log(s) for this service
-mongo:promote <name> <app>     Promote service <name> as MONGO_URL in <app>
-mongo:restart <name>           Graceful shutdown and restart of the mongo service container
-mongo:start <name>             Start a previously stopped mongo service
-mongo:stop <name>              Stop a running mongo service
-mongo:unexpose <name>          Unexpose a previously exposed mongo service
-mongo:unlink <name> <app>      Unlink the mongo service from the app
-mongo:upgrade <name>           Upgrade service <service> to the specified version
+mongo:app-links <app>                              # list all mongo service links for a given app
+mongo:backup <service> <bucket-name> [--use-iam]   # create a backup of the mongo service to an existing s3 bucket
+mongo:backup-auth <service> <aws-access-key-id> <aws-secret-access-key> <aws-default-region> <aws-signature-version> <endpoint-url> # set up authentication for backups on the mongo service
+mongo:backup-deauth <service>                      # remove backup authentication for the mongo service
+mongo:backup-schedule <service> <schedule> <bucket-name> [--use-iam] # schedule a backup of the mongo service
+mongo:backup-schedule-cat <service>                # cat the contents of the configured backup cronfile for the service
+mongo:backup-set-encryption <service> <passphrase> # set encryption for all future backups of mongo service
+mongo:backup-set-public-key-encryption <service> <public-key-id> # set GPG Public Key encryption for all future backups of mongo service
+mongo:backup-unschedule <service>                  # unschedule the backup of the mongo service
+mongo:backup-unset-encryption <service>            # unset encryption for future backups of the mongo service
+mongo:backup-unset-public-key-encryption <service> # unset GPG Public Key encryption for future backups of the mongo service
+mongo:clone <service> <new-service> [--clone-flags...] # create container <new-name> then copy data from <name> into <new-name>
+mongo:connect <service>                            # connect to the service via the mongo connection tool
+mongo:connect-admin <service>                      # connect via mongo to a mongo service as admin user
+mongo:create <service> [--create-flags...]         # create a mongo service
+mongo:destroy <service> [-f|--force]               # delete the mongo service/data/container if there are no links left
+mongo:enter <service>                              # enter or run a command in a running mongo service container
+mongo:exists <service>                             # check if the mongo service exists
+mongo:export <service>                             # export a dump of the mongo service database
+mongo:expose <service> <ports...>                  # expose a mongo service on custom host:port if provided (random port on the 0.0.0.0 interface if otherwise unspecified)
+mongo:import <service>                             # import a dump into the mongo service database
+mongo:info <service> [--single-info-flag]          # print the service information
+mongo:link <service> <app> [--link-flags...]       # link the mongo service to the app
+mongo:linked <service> <app>                       # check if the mongo service is linked to an app
+mongo:links <service>                              # list all apps linked to the mongo service
+mongo:list                                         # list all mongo services
+mongo:logs <service> [-t|--tail] <tail-num-optional> # print the most recent log(s) for this service
+mongo:pause <service>                              # pause a running mongo service
+mongo:promote <service> <app>                      # promote service <service> as MONGO_URL in <app>
+mongo:restart <service>                            # graceful shutdown and restart of the mongo service container
+mongo:set <service> <key> <value>                  # set or clear a property for a service
+mongo:start <service>                              # start a previously stopped mongo service
+mongo:stop <service>                               # stop a running mongo service
+mongo:unexpose <service>                           # unexpose a previously exposed mongo service
+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. Plugin help output in conjunction with any files in the `docs/` folder is used to generate the plugin documentation. Please consult the `mongo:help` command for any undocumented commands.
+
+### Basic Usage
+
+### create a mongo service
 
 ```shell
-# create a mongo service named lolipop
-dokku mongo:create lolipop
+# usage
+dokku mongo: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 mongo image
+flags:
+
+- `-c|--config-options "--args --go=here"`: extra arguments to pass to the container create command (default: ` --storageEngine wiredTiger --auth `)
+- `-C|--custom-env "USER=alpha;HOST=beta"`: semi-colon delimited environment variables to start the service with
+- `-i|--image IMAGE`: the image name to start the service with
+- `-I|--image-version IMAGE_VERSION`: the image version to start the service with
+- `-m|--memory MEMORY`: container memory limit in megabytes (default: unlimited)
+- `-N|--initial-network INITIAL_NETWORK`: the initial network to attach the service to
+- `-p|--password PASSWORD`: override the user-level service password
+- `-P|--post-create-network NETWORKS`: a comma-separated list of networks to attach the service container to after service creation
+- `-r|--root-password PASSWORD`: override the root-level service password
+- `-S|--post-start-network NETWORKS`: a comma-separated list of networks to attach the service container to after service start
+- `-s|--shm-size SHM_SIZE`: override shared memory size for mongo docker container
+
+Create a mongo service named lollipop:
+
+```shell
+dokku mongo:create lollipop
+```
+
+You can also specify the image and image version to use for the service. It *must* be compatible with the mongo image.
+
+```shell
 export MONGO_IMAGE="mongo"
-export MONGO_IMAGE_VERSION="3.0.5"
-dokku mongo:create lolipop
+export MONGO_IMAGE_VERSION="${PLUGIN_IMAGE_VERSION}"
+dokku mongo:create lollipop
+```
 
-# you can also specify custom environment
-# variables to start the mongo service
-# in semi-colon separated form
+You can also specify custom environment variables to start the mongo service in semicolon-separated form.
+
+```shell
 export MONGO_CUSTOM_ENV="USER=alpha;HOST=beta"
-dokku mongo:create lolipop
+dokku mongo:create lollipop
+```
 
-# by default we use the wiredTiger storage solution
-# 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
+### print the service information
 
-# get connection information as follows
-dokku mongo:info lolipop
+```shell
+# usage
+dokku mongo:info <service> [--single-info-flag]
+```
 
-# you can also retrieve a specific piece of service info via flags
-dokku mongo:info lolipop --config-dir
-dokku mongo:info lolipop --data-dir
-dokku mongo:info lolipop --dsn
-dokku mongo:info lolipop --exposed-ports
-dokku mongo:info lolipop --id
-dokku mongo:info lolipop --internal-ip
-dokku mongo:info lolipop --links
-dokku mongo:info lolipop --service-root
-dokku mongo:info lolipop --status
-dokku mongo:info lolipop --version
+flags:
 
-# a bash prompt can be opened against a running service
-# filesystem changes will not be saved to disk
-dokku mongo:enter lolipop
+- `--config-dir`: show the service configuration directory
+- `--data-dir`: show the service data directory
+- `--dsn`: show the service DSN
+- `--exposed-ports`: show service exposed ports
+- `--id`: show the service container id
+- `--internal-ip`: show the service internal ip
+- `--initial-network`: show the initial network being connected to
+- `--links`: show the service app links
+- `--post-create-network`: show the networks to attach to after service container creation
+- `--post-start-network`: show the networks to attach to after service container start
+- `--service-root`: show the service root directory
+- `--status`: show the service running status
+- `--version`: show the service image version
 
-# you may also run a command directly against the service
-# filesystem changes will not be saved to disk
-dokku mongo:enter lolipop ls -lah /
+Get connection information as follows:
 
-# 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
-dokku mongo:link lolipop playground
+```shell
+dokku mongo:info lollipop
+```
 
-# 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_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`.
+You can also retrieve a specific piece of service info via flags:
 
-# another service can be linked to your app
+```shell
+dokku mongo:info lollipop --config-dir
+dokku mongo:info lollipop --data-dir
+dokku mongo:info lollipop --dsn
+dokku mongo:info lollipop --exposed-ports
+dokku mongo:info lollipop --id
+dokku mongo:info lollipop --internal-ip
+dokku mongo:info lollipop --initial-network
+dokku mongo:info lollipop --links
+dokku mongo:info lollipop --post-create-network
+dokku mongo:info lollipop --post-start-network
+dokku mongo:info lollipop --service-root
+dokku mongo:info lollipop --status
+dokku mongo:info lollipop --version
+```
+
+### list all mongo services
+
+```shell
+# usage
+dokku mongo:list
+```
+
+List all services:
+
+```shell
+dokku mongo:list
+```
+
+### print the most recent log(s) for this service
+
+```shell
+# usage
+dokku mongo:logs <service> [-t|--tail] <tail-num-optional>
+```
+
+flags:
+
+- `-t|--tail [<tail-num>]`: do not stop when end of the logs are reached and wait for additional output
+
+You can tail logs for a particular service:
+
+```shell
+dokku mongo:logs lollipop
+```
+
+By default, logs will not be tailed, but you can do this with the --tail flag:
+
+```shell
+dokku mongo:logs lollipop --tail
+```
+
+The default tail setting is to show all logs, but an initial count can also be specified:
+
+```shell
+dokku mongo:logs lollipop --tail 5
+```
+
+### link the mongo service to the app
+
+```shell
+# usage
+dokku mongo:link <service> <app> [--link-flags...]
+```
+
+flags:
+
+- `-a|--alias "BLUE_DATABASE"`: an alternative alias to use for linking to an app via environment variable
+- `-q|--querystring "pool=5"`: ampersand delimited querystring arguments to append to the service link
+- `-n|--no-restart "false"`: whether or not to restart the app on link (default: true)
+
+A 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 lollipop playground
+```
+
+The following environment variables will be set automatically by docker (not on the app itself, so they won’t be listed when calling dokku config):
+
+```
+DOKKU_MONGO_LOLLIPOP_NAME=/lollipop/DATABASE
+DOKKU_MONGO_LOLLIPOP_PORT=tcp://172.17.0.1:27017
+DOKKU_MONGO_LOLLIPOP_PORT_27017_TCP=tcp://172.17.0.1:27017
+DOKKU_MONGO_LOLLIPOP_PORT_27017_TCP_PROTO=tcp
+DOKKU_MONGO_LOLLIPOP_PORT_27017_TCP_PORT=27017
+DOKKU_MONGO_LOLLIPOP_PORT_27017_TCP_ADDR=172.17.0.1
+```
+
+The following will be set on the linked application by default:
+
+```
+MONGO_URL=mongodb://lollipop:SOME_PASSWORD@dokku-mongo-lollipop:27017/lollipop
+```
+
+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 mongo:link other_service playground
+```
 
-# since DATABASE_URL is already in use, another environment variable will be
-# generated automatically
-#
-#   DOKKU_MONGO_BLUE_URL=mongodb://other_service:ANOTHER_PASSWORD@dokku-mongo-other-service:27017/other_service
+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.
 
-# you can then promote the new service to be the primary one
-# NOTE: this will restart your app
+```shell
+dokku config:set playground MONGO_DATABASE_SCHEME=mongodb2
+dokku mongo:link lollipop playground
+```
+
+This will cause `MONGO_URL` to be set as:
+
+```
+mongodb2://lollipop:SOME_PASSWORD@dokku-mongo-lollipop:27017/lollipop
+```
+
+### unlink the mongo service from the app
+
+```shell
+# usage
+dokku mongo:unlink <service> <app>
+```
+
+flags:
+
+- `-n|--no-restart "false"`: whether or not to restart the app on unlink (default: true)
+
+You can unlink a mongo service:
+
+> NOTE: this will restart your app and unset related environment variables
+
+```shell
+dokku mongo:unlink lollipop playground
+```
+
+### set or clear a property for a service
+
+```shell
+# usage
+dokku mongo:set <service> <key> <value>
+```
+
+Set the network to attach after the service container is started:
+
+```shell
+dokku mongo:set lollipop post-create-network custom-network
+```
+
+Set multiple networks:
+
+```shell
+dokku mongo:set lollipop post-create-network custom-network,other-network
+```
+
+Unset the post-create-network value:
+
+```shell
+dokku mongo:set lollipop post-create-network
+```
+
+### Service Lifecycle
+
+The lifecycle of each service can be managed through the following commands:
+
+### connect to the service via the mongo connection tool
+
+```shell
+# usage
+dokku mongo:connect <service>
+```
+
+Connect to the service via the mongo connection tool:
+
+> NOTE: disconnecting from ssh while running this command may leave zombie processes due to moby/moby#9098
+
+```shell
+dokku mongo:connect lollipop
+```
+
+### 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.
+
+> NOTE: disconnecting from ssh while running this command may leave zombie processes due to moby/moby#9098
+
+```shell
+dokku mongo:enter lollipop
+```
+
+You may also run a command directly against the service. Filesystem changes will not be saved to disk.
+
+```shell
+dokku mongo:enter lollipop touch /tmp/test
+```
+
+### expose a mongo service on custom host:port if provided (random port on the 0.0.0.0 interface if otherwise unspecified)
+
+```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 lollipop 27017 27018 27019 28017
+```
+
+Expose the service on the service's normal ports, with the first on a specified ip address (127.0.0.1):
+
+```shell
+dokku mongo:expose lollipop 127.0.0.1:27017 27018 27019 28017
+```
+
+### 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 lollipop
+```
+
+### 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
-
-# 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
-
-It's possible to change the protocol for MONGO_URL by setting
-the environment variable MONGO_DATABASE_SCHEME on the app:
+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:
 
 ```
-dokku config:set playground MONGO_DATABASE_SCHEME=mongo2
-dokku mongo:link lolipop playground
+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://lollipop:SOME_PASSWORD@dokku-mongo-lollipop:27017/lollipop
 ```
 
-Will cause MONGO_URL to be set as
-mongo2://lolipop:SOME_PASSWORD@dokku-mongo-lolipop:27017/lolipop
+### start a previously stopped mongo service
 
-CAUTION: Changing MONGO_DATABASE_SCHEME after linking will cause dokku to
-believe the mongo is not linked when attempting to use `dokku mongo:unlink`
-or `dokku mongo:promote`.
-You should be able to fix this by
+```shell
+# usage
+dokku mongo:start <service>
+```
 
-- Changing MONGO_URL manually to the new value.
+Start the service:
 
-OR
+```shell
+dokku mongo:start lollipop
+```
 
-- Set MONGO_DATABASE_SCHEME back to its original setting
-- Unlink the service
-- Change MONGO_DATABASE_SCHEME to the desired setting
-- Relink the service
+### stop a running mongo service
 
-## Backups
+```shell
+# usage
+dokku mongo:stop <service>
+```
+
+Stop the service and removes the running container:
+
+```shell
+dokku mongo:stop lollipop
+```
+
+### pause a running mongo service
+
+```shell
+# usage
+dokku mongo:pause <service>
+```
+
+Pause the running container for the service:
+
+```shell
+dokku mongo:pause lollipop
+```
+
+### graceful shutdown and restart of the mongo service container
+
+```shell
+# usage
+dokku mongo:restart <service>
+```
+
+Restart the service:
+
+```shell
+dokku mongo:restart lollipop
+```
+
+### upgrade service <service> to the specified versions
+
+```shell
+# usage
+dokku mongo:upgrade <service> [--upgrade-flags...]
+```
+
+flags:
+
+- `-c|--config-options "--args --go=here"`: extra arguments to pass to the container create command (default: ` --storageEngine wiredTiger --auth `)
+- `-C|--custom-env "USER=alpha;HOST=beta"`: semi-colon delimited environment variables to start the service with
+- `-i|--image IMAGE`: the image name to start the service with
+- `-I|--image-version IMAGE_VERSION`: the image version to start the service with
+- `-N|--initial-network INITIAL_NETWORK`: the initial network to attach the service to
+- `-P|--post-create-network NETWORKS`: a comma-separated list of networks to attach the service container to after service creation
+- `-R|--restart-apps "true"`: whether or not to force an app restart (default: false)
+- `-S|--post-start-network NETWORKS`: a comma-separated list of networks to attach the service container to after service start
+- `-s|--shm-size SHM_SIZE`: override shared memory size for mongo docker container
+
+You can upgrade an existing service to a new image or image-version:
+
+```shell
+dokku mongo:upgrade lollipop
+```
+
+### 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...]
+```
+
+flags:
+
+- `-c|--config-options "--args --go=here"`: extra arguments to pass to the container create command (default: ` --storageEngine wiredTiger --auth `)
+- `-C|--custom-env "USER=alpha;HOST=beta"`: semi-colon delimited environment variables to start the service with
+- `-i|--image IMAGE`: the image name to start the service with
+- `-I|--image-version IMAGE_VERSION`: the image version to start the service with
+- `-m|--memory MEMORY`: container memory limit in megabytes (default: unlimited)
+- `-N|--initial-network INITIAL_NETWORK`: the initial network to attach the service to
+- `-p|--password PASSWORD`: override the user-level service password
+- `-P|--post-create-network NETWORKS`: a comma-separated list of networks to attach the service container to after service creation
+- `-r|--root-password PASSWORD`: override the root-level service password
+- `-S|--post-start-network NETWORKS`: a comma-separated list of networks to attach the service container to after service start
+- `-s|--shm-size SHM_SIZE`: override shared memory size for mongo docker container
+
+You can clone an existing service to a new one:
+
+```shell
+dokku mongo:clone lollipop lollipop-2
+```
+
+### check if the mongo service exists
+
+```shell
+# usage
+dokku mongo:exists <service>
+```
+
+Here we check if the lollipop mongo service exists.
+
+```shell
+dokku mongo:exists lollipop
+```
+
+### check if the mongo service is linked to an app
+
+```shell
+# usage
+dokku mongo:linked <service> <app>
+```
+
+Here we check if the lollipop mongo service is linked to the `playground` app.
+
+```shell
+dokku mongo:linked lollipop playground
+```
+
+### list all apps linked to the mongo service
+
+```shell
+# usage
+dokku mongo:links <service>
+```
+
+List all apps linked to the `lollipop` mongo service.
+
+```shell
+dokku mongo:links lollipop
+```
+
+### 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 lollipop < data.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 lollipop
+```
+
+You can redirect this output to a file:
+
+```shell
+dokku mongo:export lollipop > data.dump
+```
+
+### Backups
 
 Datastore backups are supported via AWS S3 and S3 compatible services like [minio](https://github.com/minio/minio).
 
-You may skip the `backup-auth` step if your dokku install is running within EC2
-and has access to the bucket via an IAM profile. In that case, use the `--use-iam`
-option with the `backup` command.
+You may skip the `backup-auth` step if your dokku install is running within EC2 and has access to the bucket via an IAM profile. In that case, use the `--use-iam` option with the `backup` command.
 
 Backups can be performed using the backup commands:
 
-```
-# setup s3 backup authentication
-dokku mongo:backup-auth lolipop AWS_ACCESS_KEY_ID AWS_SECRET_ACCESS_KEY
+### set up authentication for backups on the mongo service
 
-# 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
+```shell
+# usage
+dokku mongo:backup-auth <service> <aws-access-key-id> <aws-secret-access-key> <aws-default-region> <aws-signature-version> <endpoint-url>
 ```
 
-Backup auth can also be set up for different regions, signature versions and endpoints (e.g. for minio):
- 
-```
-# setup s3 backup authentication with different region
-dokku mongo:backup-auth lolipop AWS_ACCESS_KEY_ID AWS_SECRET_ACCESS_KEY AWS_REGION
- 
-# setup s3 backup authentication with different signature version and endpoint
-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
-dokku mongo:backup-auth lolipop MINIO_ACCESS_KEY_ID MINIO_SECRET_ACCESS_KEY us-east-1 s3v4 https://YOURMINIOSERVICE
+Setup s3 backup authentication:
+
+```shell
+dokku mongo:backup-auth lollipop AWS_ACCESS_KEY_ID AWS_SECRET_ACCESS_KEY
 ```
 
-## Disabling `docker pull` calls
+Setup s3 backup authentication with different region:
 
-If you wish to disable the `docker pull` calls that the plugin triggers, you may set the `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.
+```shell
+dokku mongo:backup-auth lollipop AWS_ACCESS_KEY_ID AWS_SECRET_ACCESS_KEY AWS_REGION
+```
 
-Please ensure the proper images are in place when `docker pull` is disabled.
+Setup s3 backup authentication with different signature version and endpoint:
+
+```shell
+dokku mongo:backup-auth lollipop AWS_ACCESS_KEY_ID AWS_SECRET_ACCESS_KEY AWS_REGION AWS_SIGNATURE_VERSION ENDPOINT_URL
+```
+
+More specific example for minio auth:
+
+```shell
+dokku mongo:backup-auth lollipop MINIO_ACCESS_KEY_ID MINIO_SECRET_ACCESS_KEY us-east-1 s3v4 https://YOURMINIOSERVICE
+```
+
+### remove backup authentication for the mongo service
+
+```shell
+# usage
+dokku mongo:backup-deauth <service>
+```
+
+Remove s3 authentication:
+
+```shell
+dokku mongo:backup-deauth lollipop
+```
+
+### create a backup of the mongo service to an existing s3 bucket
+
+```shell
+# usage
+dokku mongo:backup <service> <bucket-name> [--use-iam]
+```
+
+flags:
+
+- `-u|--use-iam`: use the IAM profile associated with the current server
+
+Backup the `lollipop` service to the `my-s3-bucket` bucket on `AWS`:`
+
+```shell
+dokku mongo:backup lollipop my-s3-bucket --use-iam
+```
+
+Restore a backup file (assuming it was extracted via `tar -xf backup.tgz`):
+
+```shell
+dokku mongo:import lollipop < backup-folder/export
+```
+
+### set encryption for all future backups of mongo service
+
+```shell
+# usage
+dokku mongo:backup-set-encryption <service> <passphrase>
+```
+
+Set the GPG-compatible passphrase for encrypting backups for backups:
+
+```shell
+dokku mongo:backup-set-encryption lollipop
+```
+
+### set GPG Public Key encryption for all future backups of mongo service
+
+```shell
+# usage
+dokku mongo:backup-set-public-key-encryption <service> <public-key-id>
+```
+
+Set the `GPG` Public Key for encrypting backups:
+
+```shell
+dokku mongo:backup-set-public-key-encryption lollipop
+```
+
+### unset encryption for future backups of the mongo service
+
+```shell
+# usage
+dokku mongo:backup-unset-encryption <service>
+```
+
+Unset the `GPG` encryption passphrase for backups:
+
+```shell
+dokku mongo:backup-unset-encryption lollipop
+```
+
+### unset GPG Public Key encryption for future backups of the mongo service
+
+```shell
+# usage
+dokku mongo:backup-unset-public-key-encryption <service>
+```
+
+Unset the `GPG` Public Key encryption for backups:
+
+```shell
+dokku mongo:backup-unset-public-key-encryption lollipop
+```
+
+### schedule a backup of the mongo service
+
+```shell
+# usage
+dokku mongo: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 mongo:backup-schedule lollipop "0 3 * * *" my-s3-bucket
+```
+
+Schedule a backup and authenticate via iam:
+
+```shell
+dokku mongo:backup-schedule lollipop "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 lollipop
+```
+
+### unschedule the backup of the mongo service
+
+```shell
+# usage
+dokku mongo:backup-unschedule <service>
+```
+
+Remove the scheduled backup from cron:
+
+```shell
+dokku mongo:backup-unschedule lollipop
+```
+
+### Disabling `docker image pull` calls
+
+If you wish to disable the `docker image pull` calls that the plugin triggers, you may set the `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 image pull` is disabled.

Vagrantfile

@@ -1,7 +1,7 @@
 # -*- mode: ruby -*-
 # vi: set ft=ruby :
 
-BOX_NAME = ENV["BOX_NAME"] || "bento/ubuntu-18.04"
+BOX_NAME = ENV["BOX_NAME"] || "bento/ubuntu-24.04"
 BOX_MEMORY = ENV["BOX_MEMORY"] || "2048"
 DOKKU_VERSION = "master"
 

bin/generate

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

commands

@@ -1,7 +1,8 @@
 #!/usr/bin/env bash
 source "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/config"
 [[ " help $PLUGIN_COMMAND_PREFIX:help $PLUGIN_COMMAND_PREFIX $PLUGIN_COMMAND_PREFIX:default " == *" $1 "* ]] || [[ "$1" == "$PLUGIN_COMMAND_PREFIX:"* ]] || exit "$DOKKU_NOT_IMPLEMENTED_EXIT"
-source "$PLUGIN_BASE_PATH/common/functions"
+source "$PLUGIN_CORE_AVAILABLE_PATH/common/functions"
+
 set -eo pipefail
 [[ $DOKKU_TRACE ]] && set -x
 

common-functions

@@ -1,10 +1,91 @@
 #!/usr/bin/env bash
+source "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/config"
 set -eo pipefail
 [[ $DOKKU_TRACE ]] && set -x
+source "$PLUGIN_CORE_AVAILABLE_PATH/common/property-functions"
 source "$PLUGIN_AVAILABLE_PATH/config/functions"
 
+add_to_links_file() {
+  declare desc="add an app to the service link file"
+  declare SERVICE="$1" APP="$2"
+  local SERVICE_ROOT="$PLUGIN_DATA_ROOT/$SERVICE"
+  local LINKS_FILE="$SERVICE_ROOT/LINKS"
+
+  touch "$LINKS_FILE"
+  sed -i.bak "/^$APP\$/d" "$LINKS_FILE" && rm "$LINKS_FILE.bak"
+  echo "$APP" >>"$LINKS_FILE"
+  sort "$LINKS_FILE" -u -o "$LINKS_FILE"
+}
+
+auth_service_filter() {
+  declare desc="calls user-service plugin trigger"
+  declare SERVICES=("$@")
+  local user_auth_count
+
+  if [[ "${#SERVICES[@]}" -eq 0 ]]; then
+    return
+  fi
+
+  user_auth_count="$(find "$PLUGIN_PATH"/enabled/*/user-auth-service 2>/dev/null | wc -l)"
+
+  # no plugin trigger exists
+  if [[ $user_auth_count == 0 ]]; then
+    # echo out all the services since there is no plugin trigger
+    for SERVICE in "${SERVICES[@]}"; do
+      [[ -n "$SERVICE" ]] && echo "$SERVICE"
+    done
+    return 0
+  fi
+
+  # this plugin trigger exists in the core `20_events` plugin
+  if [[ "$user_auth_count" == 1 ]] && [[ -f "$PLUGIN_PATH"/enabled/20_events/user-auth-service ]]; then
+    # echo out all the services since there is no valid plugin trigger
+    for SERVICE in "${SERVICES[@]}"; do
+      [[ -n "$SERVICE" ]] && echo "$SERVICE"
+    done
+    return 0
+  fi
+
+  export SSH_USER=${SSH_USER:=$USER}
+  export SSH_NAME=${NAME:="default"}
+  # the output of this trigger should be all the services a user has access to
+  plugn trigger user-auth-service "$SSH_USER" "$SSH_NAME" "$PLUGIN_COMMAND_PREFIX" "${SERVICES[@]}"
+}
+
+fn-services-list() {
+  declare desc="prints a filtered list of all local apps"
+  declare FILTER="$1"
+  local services=()
+
+  pushd "$PLUGIN_DATA_ROOT" >/dev/null
+  for f in *; do
+    [[ -d $f ]] || continue
+    services+=("$f")
+  done
+  popd >/dev/null 2>&1 || pushd "/tmp" >/dev/null
+
+  if [[ "${#services[@]}" -eq 0 ]]; then
+    return
+  fi
+
+  if [[ "$FILTER" == "false" ]]; then
+    for service in "${services[@]}"; do
+      if [[ -n "$service" ]]; then
+        echo "$service"
+      fi
+    done
+    return
+  fi
+
+  for service in $(auth_service_filter "${services[@]}" 2>/dev/null); do
+    if [[ -n "$service" ]]; then
+      echo "$service"
+    fi
+  done
+}
+
 docker_ports_options() {
-  declare desc="Exports a list of exposed ports"
+  declare desc="export a list of exposed ports"
   declare PORTS=("$@")
   for ((i = 0; i < ${#PLUGIN_DATASTORE_PORTS[@]}; i++)); do
     echo -n "-p ${PORTS[i]}:${PLUGIN_DATASTORE_PORTS[i]} "
@@ -12,25 +93,25 @@ docker_ports_options() {
 }
 
 get_container_ip() {
-  declare desc="Retrieves the ip address of a container"
+  declare desc="retrieve the ip address of a container"
   declare CONTAINER_ID="$1"
-  docker inspect --format '{{ .NetworkSettings.IPAddress }}' "$CONTAINER_ID" 2>/dev/null
+  "$DOCKER_BIN" container inspect --format '{{ .NetworkSettings.IPAddress }}' "$CONTAINER_ID" 2>/dev/null
 }
 
 get_database_name() {
-  declare desc="Retrieves a sanitized database name"
+  declare desc="retrieve a sanitized database name"
   declare SERVICE="$1"
   local SERVICE_ROOT="$PLUGIN_DATA_ROOT/$SERVICE"
 
   if [[ ! -f "$SERVICE_ROOT/DATABASE_NAME" ]]; then
-    echo "$SERVICE" > "$SERVICE_ROOT/DATABASE_NAME"
+    echo "$SERVICE" >"$SERVICE_ROOT/DATABASE_NAME"
   fi
 
   cat "$SERVICE_ROOT/DATABASE_NAME"
 }
 
 get_random_ports() {
-  declare desc="Retrieves N random ports"
+  declare desc="retrieve N random ports"
   declare iterations="${1:-1}"
   for ((i = 0; i < iterations; i++)); do
     local port=$RANDOM
@@ -49,22 +130,31 @@ get_random_ports() {
 }
 
 get_service_name() {
-  declare desc="Retrieves a docker service label"
+  declare desc="retrieve a docker service label"
   declare SERVICE="$1"
   echo "dokku.${PLUGIN_COMMAND_PREFIX}.$SERVICE"
 }
 
 get_url_from_config() {
-  declare desc="Retrieves a given _URL from a list of configuration variables"
+  declare desc="retrieve a given _URL from a list of configuration variables"
   declare EXISTING_CONFIG="$1" CONFIG_VAR="$2"
   echo "$EXISTING_CONFIG" | grep "$CONFIG_VAR" | sed "s/$CONFIG_VAR:\s*//" | xargs
 }
 
+in_links_file() {
+  declare desc="check if a service LINKS file contains an app"
+  declare SERVICE="$1" APP="$2"
+  local SERVICE_ROOT="$PLUGIN_DATA_ROOT/$SERVICE"
+  local LINKS_FILE="$SERVICE_ROOT/LINKS"
+
+  grep -qE "^$APP\$" "$LINKS_FILE"
+}
+
 is_container_status() {
-  declare desc="Returns 0 or 1 depending upon whether a given container has a certain status"
+  declare desc="return 0 or 1 depending upon whether a given container has a certain status"
   declare CID="$1" STATUS="$2"
   local TEMPLATE="{{.State.$STATUS}}"
-  local CONTAINER_STATUS=$(docker inspect -f "$TEMPLATE" "$CID" 2>/dev/null || true)
+  local CONTAINER_STATUS=$("$DOCKER_BIN" container inspect -f "$TEMPLATE" "$CID" 2>/dev/null || true)
 
   if [[ "$CONTAINER_STATUS" == "true" ]]; then
     return 0
@@ -89,7 +179,7 @@ is_implemented_command() {
 }
 
 is_valid_service_name() {
-  declare desc="Validates a service name"
+  declare desc="validate a service name"
   declare SERVICE="$1"
   [[ -z "$SERVICE" ]] && return 1
 
@@ -101,7 +191,7 @@ is_valid_service_name() {
 }
 
 remove_from_links_file() {
-  declare desc="Removes an app from the service link file"
+  declare desc="remove an app from the service link file"
   declare SERVICE="$1" APP="$2"
   local SERVICE_ROOT="$PLUGIN_DATA_ROOT/$SERVICE"
   local LINKS_FILE="$SERVICE_ROOT/LINKS"
@@ -119,7 +209,7 @@ retry-docker-command() {
   local i=0 success=false
   until [ $i -ge 100 ]; do
     set +e
-    docker exec -it "$ID" sh -c "$COMMAND" 2>/dev/null
+    suppress_output "$DOCKER_BIN" container exec "$ID" sh -c "$COMMAND"
     exit_code=$?
     set -e
     if [[ "$exit_code" == 0 ]]; then
@@ -136,7 +226,7 @@ retry-docker-command() {
 }
 
 service_alternative_alias() {
-  declare desc="Retrieves an alternative alias for a service"
+  declare desc="retrieve an alternative alias for a service"
   declare EXISTING_CONFIG="$1"
   local COLORS=(AQUA BLACK BLUE FUCHSIA GRAY GREEN LIME MAROON NAVY OLIVE PURPLE RED SILVER TEAL WHITE YELLOW)
   local ALIAS
@@ -153,14 +243,16 @@ service_alternative_alias() {
 }
 
 service_app_links() {
-  declare desc="Outputs all service links for a given app"
+  declare desc="output all service links for a given app"
   declare APP="$1"
-  local SERVICE LINKED_APP
+  local LINKED_APP SERVICE SERVICE_ROOT
 
-  pushd "$PLUGIN_DATA_ROOT" >/dev/null
-  for SERVICE in *; do
-    [[ -f "$SERVICE/LINKS" ]] || continue
-    for LINKED_APP in $(<"$SERVICE/LINKS"); do
+  for SERVICE in $(fn-services-list true); do
+    [[ -n "$SERVICE" ]] || continue
+
+    SERVICE_ROOT="$PLUGIN_DATA_ROOT/$SERVICE"
+    [[ -f "$SERVICE_ROOT/LINKS" ]] || continue
+    for LINKED_APP in $(<"$SERVICE_ROOT/LINKS"); do
       if [[ "$LINKED_APP" == "$APP" ]]; then
         echo "$SERVICE"
       fi
@@ -169,7 +261,7 @@ service_app_links() {
 }
 
 service_backup() {
-  declare desc="Creates a backup of a service to an existing s3 bucket"
+  declare desc="create a backup of a service to an existing s3 bucket"
   declare SERVICE="$1" BUCKET_NAME="$2" USE_IAM_OPTIONAL_FLAG="$3"
   local SERVICE_BACKUP_ROOT="$PLUGIN_DATA_ROOT/$SERVICE/backup"
   local BACKUP_ENCRYPTION_CONFIG_ROOT="$PLUGIN_DATA_ROOT/$SERVICE/backup-encryption"
@@ -187,18 +279,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"
+  "$DOCKER_BIN" container inspect "$ID" >/dev/null 2>&1 || 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")"
@@ -216,12 +308,67 @@ service_backup() {
     BACKUP_PARAMETERS="$BACKUP_PARAMETERS -e ENCRYPTION_KEY=$(cat "$BACKUP_ENCRYPTION_CONFIG_ROOT/ENCRYPTION_KEY")"
   fi
 
+  if [[ -f "$BACKUP_ENCRYPTION_CONFIG_ROOT/ENCRYPT_WITH_PUBLIC_KEY_ID" ]]; then
+    BACKUP_PARAMETERS="$BACKUP_PARAMETERS -e ENCRYPT_WITH_PUBLIC_KEY_ID=$(cat "$BACKUP_ENCRYPTION_CONFIG_ROOT/ENCRYPT_WITH_PUBLIC_KEY_ID")"
+  fi
+
   # shellcheck disable=SC2086
-  docker run --rm $BACKUP_PARAMETERS dokku/s3backup:0.10.1
+  "$DOCKER_BIN" container run --rm $BACKUP_PARAMETERS "$PLUGIN_S3BACKUP_IMAGE"
+}
+
+service_commit_config() {
+  declare SERVICE="$1"
+  local SERVICE_ROOT="$PLUGIN_DATA_ROOT/$SERVICE"
+  local CONFIG_VARIABLE="${PLUGIN_VARIABLE}_CONFIG_OPTIONS"
+  local ENV_VARIABLE="${PLUGIN_VARIABLE}_CUSTOM_ENV"
+
+  custom_env="${!ENV_VARIABLE}"
+  [[ -n "$SERVICE_CUSTOM_ENV" ]] && custom_env="$SERVICE_CUSTOM_ENV"
+  if [[ -n $custom_env ]]; then
+    echo "$custom_env" | tr ';' "\n" >"$SERVICE_ROOT/ENV"
+  else
+    echo "" >"$SERVICE_ROOT/ENV"
+  fi
+
+  config_options="${!CONFIG_VARIABLE}"
+  [[ -n "$PLUGIN_CONFIG_OPTIONS" ]] && config_options="$PLUGIN_CONFIG_OPTIONS"
+  if [[ -n "$config_options" ]]; then
+    echo "$config_options" >"$SERVICE_ROOT/CONFIG_OPTIONS"
+  else
+    echo "" >"$SERVICE_ROOT/CONFIG_OPTIONS"
+  fi
+
+  if [[ -n "$SERVICE_MEMORY" ]]; then
+    echo "$SERVICE_MEMORY" >"$SERVICE_ROOT/SERVICE_MEMORY"
+  fi
+
+  if [[ -n "$SERVICE_SHM_SIZE" ]]; then
+    echo "$SERVICE_SHM_SIZE" >"$SERVICE_ROOT/SHM_SIZE"
+  fi
+
+  if [[ -n "$PLUGIN_IMAGE" ]]; then
+    echo "$PLUGIN_IMAGE" >"$SERVICE_ROOT/IMAGE"
+  fi
+
+  if [[ -n "$PLUGIN_IMAGE_VERSION" ]]; then
+    echo "$PLUGIN_IMAGE_VERSION" >"$SERVICE_ROOT/IMAGE_VERSION"
+  fi
+
+  if [[ -n "$SERVICE_INITIAL_NETWORK" ]]; then
+    fn-plugin-property-write "$PLUGIN_COMMAND_PREFIX" "$SERVICE" "initial-network" "$SERVICE_INITIAL_NETWORK"
+  fi
+
+  if [[ -n "$SERVICE_POST_CREATE_NETWORK" ]]; then
+    fn-plugin-property-write "$PLUGIN_COMMAND_PREFIX" "$SERVICE" "post-create-network" "$SERVICE_POST_CREATE_NETWORK"
+  fi
+
+  if [[ -n "$SERVICE_POST_START_NETWORK" ]]; then
+    fn-plugin-property-write "$PLUGIN_COMMAND_PREFIX" "$SERVICE" "post-start-network" "$SERVICE_POST_START_NETWORK"
+  fi
 }
 
 service_backup_auth() {
-  declare desc="Sets up authentication"
+  declare desc="set up authentication"
   declare SERVICE="$1" AWS_ACCESS_KEY_ID="$2" AWS_SECRET_ACCESS_KEY="$3" AWS_DEFAULT_REGION="$4" AWS_SIGNATURE_VERSION="$5" ENDPOINT_URL="$6"
   local SERVICE_BACKUP_ROOT="$PLUGIN_DATA_ROOT/$SERVICE/backup"
 
@@ -243,7 +390,7 @@ service_backup_auth() {
 }
 
 service_backup_deauth() {
-  declare desc="Removes authentication"
+  declare desc="remove authentication"
   declare SERVICE="$1"
   local SERVICE_ROOT="${PLUGIN_DATA_ROOT}/${SERVICE}"
   local SERVICE_BACKUP_ROOT="${SERVICE_ROOT}/backup/"
@@ -281,7 +428,7 @@ service_backup_schedule_cat() {
 }
 
 service_backup_set_encryption() {
-  declare desc="Sets up backup encryption"
+  declare desc="set up backup encryption"
   declare SERVICE="$1" ENCRYPTION_KEY="$2"
   local SERVICE_ROOT="${PLUGIN_DATA_ROOT}/${SERVICE}"
   local SERVICE_BACKUP_ENCRYPTION_ROOT="${SERVICE_ROOT}/backup-encryption/"
@@ -290,8 +437,18 @@ service_backup_set_encryption() {
   echo "$ENCRYPTION_KEY" >"${SERVICE_BACKUP_ENCRYPTION_ROOT}/ENCRYPTION_KEY"
 }
 
+service_backup_set_public_key_encryption() {
+  declare desc="set up backup GPG Public Key encryption"
+  declare SERVICE="$1" ENCRYPT_WITH_PUBLIC_KEY_ID="$2"
+  local SERVICE_ROOT="${PLUGIN_DATA_ROOT}/${SERVICE}"
+  local SERVICE_BACKUP_ENCRYPTION_ROOT="${SERVICE_ROOT}/backup-encryption/"
+
+  mkdir "$SERVICE_BACKUP_ENCRYPTION_ROOT"
+  echo "$ENCRYPT_WITH_PUBLIC_KEY_ID" >"${SERVICE_BACKUP_ENCRYPTION_ROOT}/ENCRYPT_WITH_PUBLIC_KEY_ID"
+}
+
 service_backup_unschedule() {
-  declare desc="unschedules the backup of the service"
+  declare desc="unschedule the backup of the service"
   declare SERVICE="$1"
   local CRON_FILE="/etc/cron.d/dokku-${PLUGIN_COMMAND_PREFIX}-${SERVICE}"
 
@@ -299,7 +456,16 @@ service_backup_unschedule() {
 }
 
 service_backup_unset_encryption() {
-  declare desc="Removes backup encryption"
+  declare desc="remove backup encryption"
+  declare SERVICE="$1"
+  local SERVICE_ROOT="${PLUGIN_DATA_ROOT}/${SERVICE}"
+  local SERVICE_BACKUP_ENCRYPTION_ROOT="${SERVICE_ROOT}/backup-encryption/"
+
+  rm -rf "$SERVICE_BACKUP_ENCRYPTION_ROOT"
+}
+
+service_backup_unset_encryption() {
+  declare desc="remove backup encryption"
   declare SERVICE="$1"
   local SERVICE_ROOT="${PLUGIN_DATA_ROOT}/${SERVICE}"
   local SERVICE_BACKUP_ENCRYPTION_ROOT="${SERVICE_ROOT}/backup-encryption/"
@@ -308,49 +474,57 @@ service_backup_unset_encryption() {
 }
 
 service_container_rm() {
-  declare desc="Stops a service and removes the running container"
+  declare desc="stop a service and remove the running container"
   declare SERVICE="$1"
   local SERVICE_NAME="$(get_service_name "$SERVICE")"
   local ID
 
-  service_stop "$SERVICE"
-  ID=$(docker ps -aq --no-trunc --filter "name=^/$SERVICE_NAME$" --format '{{ .ID }}') || true
+  service_pause "$SERVICE"
+  ID=$("$DOCKER_BIN" container ps -aq --no-trunc --filter "name=^/$SERVICE_NAME$") || true
   # this may be 'true' in tests...
   if [[ -z "$ID" ]] || [[ "$ID" == "true" ]]; then
     return 0
   fi
 
   dokku_log_verbose_quiet "Removing container"
-  docker update --restart=no "$SERVICE_NAME" >/dev/null 2>&1
-  if ! docker rm "$SERVICE_NAME" >/dev/null 2>&1; then
+  "$DOCKER_BIN" container update --restart=no "$SERVICE_NAME" >/dev/null 2>&1
+  if ! "$DOCKER_BIN" container rm "$SERVICE_NAME" >/dev/null 2>&1; then
     dokku_log_fail "Unable to remove container for service $SERVICE"
   fi
 }
 
 service_dns_hostname() {
-  declare desc="Retrieves the alias of a service"
+  declare desc="retrieve the alias of a service"
   declare SERVICE="$1"
   local SERVICE_NAME="$(get_service_name "$SERVICE")"
   echo "$SERVICE_NAME" | tr ._ -
 }
 
 service_enter() {
-  declare desc="enters running app container of specified proc type"
+  declare desc="enter running app container of specified proc type"
   declare SERVICE="$1" && shift 1
   local SERVICE_ROOT="$PLUGIN_DATA_ROOT/$SERVICE"
   local ID="$(cat "$SERVICE_ROOT/ID")"
 
-  docker inspect "$ID" &>/dev/null || dokku_log_fail "Service container does not exist"
+  "$DOCKER_BIN" container inspect "$ID" >/dev/null 2>&1 || dokku_log_fail "Service container does not exist"
   is_container_status "$ID" "Running" || dokku_log_fail "Service container is not running"
 
   local EXEC_CMD=""
   has_tty && local DOKKU_RUN_OPTS+=" -i -t"
   # shellcheck disable=SC2086
-  docker exec $DOKKU_RUN_OPTS $ID $EXEC_CMD "${@:-/bin/bash}"
+  "$DOCKER_BIN" container exec $DOKKU_RUN_OPTS $ID $EXEC_CMD "${@:-/bin/bash}"
+}
+
+service_exists() {
+  declare desc="returns 0 or 1 depending on whether service exists or not"
+  declare SERVICE="$1"
+  [[ -z "$SERVICE" ]] && return 1
+  [[ -d "$PLUGIN_DATA_ROOT/$SERVICE" ]] && return 0
+  return 1
 }
 
 service_exposed_ports() {
-  declare desc="Lists exposed ports for a service"
+  declare desc="list exposed ports for a service"
   declare SERVICE="$1"
   local SERVICE_ROOT="$PLUGIN_DATA_ROOT/$SERVICE"
   local PORT_FILE="$SERVICE_ROOT/PORT"
@@ -362,10 +536,22 @@ service_exposed_ports() {
 }
 
 service_image_exists() {
-  declare desc="Checks if the current image exists"
-  local IMAGE="$PLUGIN_IMAGE:$PLUGIN_IMAGE_VERSION"
+  declare desc="check if the current image exists"
+  declare SERVICE="$1" PLUGIN_IMAGE="${2:-$PLUGIN_IMAGE}" PLUGIN_IMAGE_VERSION="${3:-$PLUGIN_IMAGE_VERSION}"
+  local plugin_image="$PLUGIN_IMAGE"
+  local plugin_image_version="$PLUGIN_IMAGE_VERSION"
 
-  if [[ "$(docker images -q "$IMAGE" 2>/dev/null)" == "" ]]; then
+  if [[ -z "$PLUGIN_IMAGE" ]] && [[ -f "$SERVICE_ROOT/IMAGE" ]]; then
+    plugin_image="$(cat "$SERVICE_ROOT/IMAGE")"
+  fi
+
+  if [[ -z "$PLUGIN_IMAGE_VERSION" ]] && [[ -f "$SERVICE_ROOT/IMAGE_VERSION" ]]; then
+    plugin_image_version="$(cat "$SERVICE_ROOT/IMAGE_VERSION")"
+  fi
+
+  local IMAGE="$plugin_image:$plugin_image_version"
+
+  if [[ "$("$DOCKER_BIN" image ls -q "$IMAGE" 2>/dev/null)" == "" ]]; then
     return 1
   fi
 
@@ -373,7 +559,7 @@ service_image_exists() {
 }
 
 service_info() {
-  declare desc="Retrieves information about a given service"
+  declare desc="retrieve information about a given service"
   declare SERVICE="$1" INFO_FLAG="$2"
   local SERVICE_ROOT="$PLUGIN_DATA_ROOT/$SERVICE"
   local SERVICE_URL=$(service_url "$SERVICE")
@@ -382,19 +568,23 @@ service_info() {
   local flag key valid_flags
 
   local flag_map=(
-    "--config-dir: ${SERVICE_ROOT}/config"
+    "--config-dir: ${SERVICE_ROOT}/${PLUGIN_CONFIG_SUFFIX}"
+    "--config-options: $(cat "$SERVICE_ROOT/CONFIG_OPTIONS" 2>/dev/null || true)"
     "--data-dir: ${SERVICE_ROOT}/data"
     "--dsn: ${SERVICE_URL}"
     "--exposed-ports: $(service_exposed_ports "$SERVICE")"
     "--id: ${SERVICE_CONTAINER_ID}"
     "--internal-ip: $(get_container_ip "${SERVICE_CONTAINER_ID}")"
+    "--initial-network: $(fn-plugin-property-get "$PLUGIN_COMMAND_PREFIX" "$SERVICE" "initial-network")"
     "--links: $(service_linked_apps "$SERVICE")"
+    "--post-create-network: $(fn-plugin-property-get "$PLUGIN_COMMAND_PREFIX" "$SERVICE" "post-create-network")"
+    "--post-start-network: $(fn-plugin-property-get "$PLUGIN_COMMAND_PREFIX" "$SERVICE" "post-start-network")"
     "--service-root: ${SERVICE_ROOT}"
     "--status: $(service_status "$SERVICE")"
     "--version: $(service_version "$SERVICE")"
   )
   if [[ -z "$INFO_FLAG" ]]; then
-    dokku_log_info2 "Container Information"
+    dokku_log_info2_quiet "$SERVICE $PLUGIN_COMMAND_PREFIX service information"
     for flag in "${flag_map[@]}"; do
       key="$(echo "${flag#--}" | cut -f1 -d' ' | tr - ' ')"
       dokku_log_verbose "$(printf "%-20s %-25s" "${key^}" "${flag#*: }")"
@@ -412,7 +602,7 @@ service_info() {
 }
 
 service_is_linked() {
-  declare desc="Links a service to an application"
+  declare desc="link a service to an application"
   declare SERVICE="$1" APP="$2"
   update_plugin_scheme_for_app "$APP"
   local SERVICE_URL=$(service_url "$SERVICE")
@@ -426,7 +616,7 @@ service_is_linked() {
 }
 
 service_link() {
-  declare desc="Links a service to an application"
+  declare desc="link a service to an application"
   declare SERVICE="$1" APP="$2"
   update_plugin_scheme_for_app "$APP"
   local SERVICE_URL=$(service_url "$SERVICE")
@@ -452,9 +642,8 @@ service_link() {
   fi
 
   [[ -n $LINK ]] && dokku_log_fail "Already linked as $LINK"
-  touch "$LINKS_FILE"
-  echo "$APP" >>"$LINKS_FILE"
-  sort "$LINKS_FILE" -u -o "$LINKS_FILE"
+  plugn trigger service-action pre-link "$PLUGIN_COMMAND_PREFIX" "$SERVICE" "$APP"
+  add_to_links_file "$SERVICE" "$APP"
 
   if declare -f -F add_passed_docker_option >/dev/null; then
     # shellcheck disable=SC2034
@@ -464,11 +653,18 @@ service_link() {
     dokku docker-options:add "$APP" build,deploy,run "--link $SERVICE_NAME:$SERVICE_DNS_HOSTNAME"
   fi
   [[ -n "$SERVICE_QUERYSTRING" ]] && SERVICE_URL="${SERVICE_URL}?${SERVICE_QUERYSTRING}"
-  config_set "$APP" "${ALIAS}_URL=$SERVICE_URL"
+  plugn trigger service-action post-link "$PLUGIN_COMMAND_PREFIX" "$SERVICE" "$APP"
+  if [[ "$DOKKU_GLOBAL_FLAGS" == *"--no-restart"* ]] || [[ "$SERVICE_RESTART_APPS" == "false" ]]; then
+    config_set --no-restart "$APP" "${ALIAS}_URL=$SERVICE_URL"
+    dokku_log_verbose "Skipping restart of linked app"
+  else
+    config_set "$APP" "${ALIAS}_URL=$SERVICE_URL"
+  fi
+  plugn trigger service-action post-link-complete "$PLUGIN_COMMAND_PREFIX" "$SERVICE" "$APP"
 }
 
 service_linked_apps() {
-  declare desc="Lists all apps linked to a service for info output"
+  declare desc="list all apps linked to a service for info output"
   declare SERVICE="$1"
   local SERVICE_ROOT="$PLUGIN_DATA_ROOT/$SERVICE"
   local LINKS_FILE="$SERVICE_ROOT/LINKS"
@@ -480,7 +676,7 @@ service_linked_apps() {
 }
 
 service_links() {
-  declare desc="Lists all apps linked to a service"
+  declare desc="list all apps linked to a service"
   declare SERVICE="$1"
   local SERVICE_ROOT="$PLUGIN_DATA_ROOT/$SERVICE"
   local LINKS_FILE="$SERVICE_ROOT/LINKS"
@@ -492,37 +688,37 @@ service_links() {
 }
 
 service_list() {
-  declare desc="Lists all services and their status"
-  local SERVICES=$(ls "$PLUGIN_DATA_ROOT" 2>/dev/null)
+  declare desc="list all services and their status"
 
-  if [[ -z $SERVICES ]]; then
+  mapfile -t services < <(fn-services-list true)
+  if [[ "${#services[@]}" -eq 0 ]] || [[ -z "$services" ]]; then
     dokku_log_warn "There are no $PLUGIN_SERVICE services"
     return
   fi
 
-  dokku_log_info2_quiet "Postgres services"
-  for SERVICE in $SERVICES; do
-    echo "$SERVICE"
+  dokku_log_info2_quiet "$PLUGIN_SERVICE services"
+  for service in "${services[@]}"; do
+    echo "${service}"
   done
 }
 
 service_logs() {
-  declare desc="Displays logs for a service"
-  declare SERVICE="$1" TAIL_FLAG="$2"
+  declare desc="display logs for a service"
+  declare SERVICE="$1" TAIL_FLAG="$2" TAIL_COUNT="$3"
   local SERVICE_ROOT="$PLUGIN_DATA_ROOT/$SERVICE"
   local ID=$(cat "$SERVICE_ROOT/ID")
   local RE_INTEGER='^[0-9]+$'
 
-  DOKKU_LOGS_ARGS="--tail 100"
+  DOKKU_LOGS_ARGS="--tail $TAIL_COUNT"
   if [[ "$TAIL_FLAG" == "-t" ]] || [[ "$TAIL_FLAG" == "--tail" ]]; then
-    DOKKU_LOGS_ARGS="--follow"
+    DOKKU_LOGS_ARGS+=" --follow"
   fi
 
-  docker inspect "$ID" &>/dev/null || dokku_log_fail "Service container does not exist"
+  "$DOCKER_BIN" container inspect "$ID" >/dev/null 2>&1 || dokku_log_fail "Service container does not exist"
   is_container_status "$ID" "Running" || dokku_log_warn "Service logs may not be output as service is not running"
 
   # shellcheck disable=SC2086
-  docker logs $DOKKU_LOGS_ARGS "$ID" 2>&1
+  "$DOCKER_BIN" container logs $DOKKU_LOGS_ARGS "$ID" 2>&1
 }
 
 service_parse_args() {
@@ -539,19 +735,24 @@ service_parse_args() {
       "--custom-env") set -- "$@" "-C" ;;
       "--database") set -- "$@" "-d" ;;
       "--image-version") set -- "$@" "-I" ;;
+      "--initial-network") set -- "$@" "-N" ;;
       "--image") set -- "$@" "-i" ;;
       "--memory") set -- "$@" "-m" ;;
+      "--no-restart") set -- "$@" "-n" ;;
       "--password") set -- "$@" "-p" ;;
+      "--post-create-network") set -- "$@" "-P" ;;
+      "--post-start-network") set -- "$@" "-S" ;;
       "--querystring") set -- "$@" "-q" ;;
       "--restart-apps") set -- "$@" "-R" ;;
       "--root-password") set -- "$@" "-r" ;;
+      "--shm-size") set -- "$@" "-s" ;;
       "--user") set -- "$@" "-u" ;;
       *) set -- "$@" "$arg" ;;
     esac
   done
 
   OPTIND=1
-  while getopts "a:c:C:d:i:I:m:p:q:R:r:u:" opt; do
+  while getopts "na:c:C:d:i:I:m:n:N:p:P:q:R:r:s:S:u:" opt; do
     case "$opt" in
       a)
         SERVICE_ALIAS="${OPTARG^^}"
@@ -575,9 +776,18 @@ service_parse_args() {
       m)
         export SERVICE_MEMORY=$OPTARG
         ;;
+      n)
+        export SERVICE_RESTART_APPS=false
+        ;;
+      N)
+        export SERVICE_INITIAL_NETWORK=$OPTARG
+        ;;
       p)
         export SERVICE_PASSWORD=$OPTARG
         ;;
+      P)
+        export SERVICE_POST_CREATE_NETWORK=$OPTARG
+        ;;
       q)
         export SERVICE_QUERYSTRING=${OPTARG#"?"}
         ;;
@@ -587,6 +797,12 @@ service_parse_args() {
       r)
         export SERVICE_ROOT_PASSWORD=$OPTARG
         ;;
+      s)
+        export SERVICE_SHM_SIZE=$OPTARG
+        ;;
+      S)
+        export SERVICE_POST_START_NETWORK=$OPTARG
+        ;;
       u)
         export SERVICE_USER=$OPTARG
         ;;
@@ -596,7 +812,7 @@ service_parse_args() {
 }
 
 service_password() {
-  declare desc="Fetch the password for a service"
+  declare desc="fetch the password for a service"
   declare SERVICE="$1"
   local SERVICE_ROOT="$PLUGIN_DATA_ROOT/$SERVICE"
   local PASSWORD_FILE="$SERVICE_ROOT/PASSWORD"
@@ -606,7 +822,7 @@ service_password() {
 }
 
 service_root_password() {
-  declare desc="Fetch the root password for a service"
+  declare desc="fetch the root password for a service"
   declare SERVICE="$1"
   local SERVICE_ROOT="$PLUGIN_DATA_ROOT/$SERVICE"
   local PASSWORD_FILE="$SERVICE_ROOT/ROOTPASSWORD"
@@ -616,84 +832,83 @@ service_root_password() {
 }
 
 service_port_expose() {
-  declare desc="Wrapper for exposing service ports"
-  declare SERVICE="$1"
-  service_start "$SERVICE" "true"
-  service_port_unpause "$SERVICE" "true" "${@:2}"
-}
-
-service_port_pause() {
-  declare desc="Pauses service exposure"
-  declare SERVICE="$1" LOG_FAIL="$2"
-  local SERVICE_ROOT="$PLUGIN_DATA_ROOT/$SERVICE"
-  local EXPOSED_NAME="$(get_service_name "$SERVICE").ambassador"
-  local PORT_FILE="$SERVICE_ROOT/PORT"
-
-  if [[ "$LOG_FAIL" == "true" ]]; then
-    [[ ! -f "$PORT_FILE" ]] && dokku_log_fail "Service not exposed"
-  else
-    [[ ! -f "$PORT_FILE" ]] && return 0
-  fi
-
-  local GREP_NAME="^/${EXPOSED_NAME}$"
-  local CONTAINER_NAME="$(docker ps -f name="$GREP_NAME" --format "{{.Names}}")"
-  if [[ -z "$CONTAINER_NAME" ]]; then
-    if [[ "$LOG_FAIL" == "true" ]]; then
-      dokku_log_info1 "Service $SERVICE unexposed"
-    fi
-
-    return
-  fi
-
-  docker stop "$EXPOSED_NAME" >/dev/null 2>&1 || true
-  docker rm "$EXPOSED_NAME" >/dev/null 2>&1 || true
-  if [[ "$LOG_FAIL" == "true" ]]; then
-    dokku_log_info1 "Service $SERVICE unexposed"
-  fi
-}
-
-service_port_unexpose() {
-  declare desc="Wrapper for pausing exposed service ports"
-  declare SERVICE="$1"
+  declare desc="wrapper for exposing service ports"
+  declare SERVICE="$1" PORTS=(${@:2})
   local SERVICE_ROOT="$PLUGIN_DATA_ROOT/$SERVICE"
   local PORT_FILE="$SERVICE_ROOT/PORT"
-  service_port_pause "$SERVICE" "true"
-  rm -rf "$PORT_FILE"
-}
-
-service_port_unpause() {
-  declare desc="Starts service exposure"
-  declare SERVICE="$1" LOG_FAIL="$2"
-  local SERVICE_ROOT="$PLUGIN_DATA_ROOT/$SERVICE"
   local SERVICE_NAME="$(get_service_name "$SERVICE")"
-  local EXPOSED_NAME="${SERVICE_NAME}.ambassador"
-  local PORT_FILE="$SERVICE_ROOT/PORT"
-  # shellcheck disable=SC2068
-  local PORTS=(${@:3})
-  # shellcheck disable=SC2068
-  PORTS=(${PORTS[@]:-$(get_random_ports ${#PLUGIN_DATASTORE_PORTS[@]})})
-  local ID=$(cat "$SERVICE_ROOT/ID")
+  local EXPOSED_NAME="$SERVICE_NAME.ambassador"
+
+  if [[ ${#PORTS[@]} -eq 0 ]]; then
+    # shellcheck disable=SC2206
+    PORTS=(${PORTS[@]:-$(get_random_ports ${#PLUGIN_DATASTORE_PORTS[@]})})
+  fi
 
   [[ "${#PORTS[@]}" != "${#PLUGIN_DATASTORE_PORTS[@]}" ]] && dokku_log_fail "${#PLUGIN_DATASTORE_PORTS[@]} ports to be exposed need to be provided in the following order: ${PLUGIN_DATASTORE_PORTS[*]}"
 
-  if [[ "$LOG_FAIL" == "true" ]]; then
-    [[ -f "$PORT_FILE" ]] && PORTS=($(cat "$PORT_FILE")) && dokku_log_fail "Service $SERVICE already exposed on port(s) ${PORTS[*]}"
-  else
-    [[ ! -f "$PORT_FILE" ]] && return 0
+  if [[ -s "$PORT_FILE" ]]; then
+    # shellcheck disable=SC2207
     PORTS=($(cat "$PORT_FILE"))
+    dokku_log_fail "Service $SERVICE already exposed on port(s) ${PORTS[*]}"
+  fi
+
+  if "$DOCKER_BIN" container inspect "$EXPOSED_NAME" >/dev/null 2>&1; then
+    dokku_log_warn "Service $SERVICE has an untracked expose container, removing"
+    "$DOCKER_BIN" container stop "$EXPOSED_NAME" >/dev/null 2>&1 || true
+    suppress_output "$DOCKER_BIN" container rm "$EXPOSED_NAME"
   fi
 
   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
-  if [[ "$LOG_FAIL" == "true" ]]; then
-    dokku_log_info1 "Service $SERVICE exposed on port(s) [container->host]: $(service_exposed_ports "$SERVICE")"
+  service_start "$SERVICE" "true"
+  service_port_reconcile_status "$SERVICE"
+  dokku_log_info1 "Service $SERVICE exposed on port(s) [container->host]: $(service_exposed_ports "$SERVICE")"
+}
+
+service_port_unexpose() {
+  declare desc="wrapper for pausing exposed service ports"
+  declare SERVICE="$1"
+  local SERVICE_ROOT="$PLUGIN_DATA_ROOT/$SERVICE"
+  local PORT_FILE="$SERVICE_ROOT/PORT"
+
+  rm -rf "$PORT_FILE"
+  service_port_reconcile_status "$SERVICE"
+  dokku_log_info1 "Service $SERVICE unexposed"
+}
+
+service_port_reconcile_status() {
+  declare SERVICE="$1"
+  local SERVICE_ROOT="$PLUGIN_DATA_ROOT/$SERVICE"
+  local PORT_FILE="$SERVICE_ROOT/PORT"
+  local SERVICE_NAME="$(get_service_name "$SERVICE")"
+  local EXPOSED_NAME="$SERVICE_NAME.ambassador"
+
+  if [[ ! -s "$PORT_FILE" ]]; then
+    if "$DOCKER_BIN" container inspect "$EXPOSED_NAME" >/dev/null 2>&1; then
+      "$DOCKER_BIN" container stop "$EXPOSED_NAME" >/dev/null 2>&1 || true
+      suppress_output "$DOCKER_BIN" container rm "$EXPOSED_NAME"
+      return $?
+    fi
+    return
   fi
+
+  if is_container_status "$EXPOSED_NAME" "Running"; then
+    return
+  fi
+
+  if "$DOCKER_BIN" container inspect "$EXPOSED_NAME" >/dev/null 2>&1; then
+    suppress_output "$DOCKER_BIN" container start "$EXPOSED_NAME"
+    return $?
+  fi
+
+  # shellcheck disable=SC2207
+  PORTS=($(cat "$PORT_FILE"))
+  # shellcheck disable=SC2046
+  "$DOCKER_BIN" container 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
 }
 
 service_promote() {
-  declare desc="Promotes a secondary service to the primary env var"
+  declare desc="promote a secondary service to the primary env var"
   declare SERVICE="$1" APP="$2"
   local PLUGIN_DEFAULT_CONFIG_VAR="${PLUGIN_DEFAULT_ALIAS}_URL"
   local EXISTING_CONFIG=$(config_all "$APP")
@@ -721,7 +936,7 @@ service_promote() {
 }
 
 service_set_alias() {
-  declare desc="Sets the alias in use for a service"
+  declare desc="sets the alias in use for a service"
   declare SERVICE="$1" ALIAS="$2"
   local SERVICE_ROOT="$PLUGIN_DATA_ROOT/$SERVICE"
   local ALIAS_FILE="$SERVICE_ROOT/ALIAS"
@@ -731,37 +946,39 @@ service_set_alias() {
 }
 
 service_status() {
-  declare desc="Displays the status of a service"
+  declare desc="display the status of a service"
   declare SERVICE="$1"
   local SERVICE_ROOT="$PLUGIN_DATA_ROOT/$SERVICE"
   local ID="$(cat "$SERVICE_ROOT/ID")"
   local CONTAINER_STATUS
 
-  CONTAINER_STATUS=$(docker inspect -f "{{.State.Status}}" "$ID" 2>/dev/null || true)
+  CONTAINER_STATUS=$("$DOCKER_BIN" container inspect -f "{{.State.Status}}" "$ID" 2>/dev/null || true)
   [[ -n "$CONTAINER_STATUS" ]] && echo "$CONTAINER_STATUS" && return 0
   echo "missing" && return 0
 }
 
-service_stop() {
-  declare desc="Stops a running service"
+service_pause() {
+  declare desc="pause a running service"
   declare SERVICE="$1"
   local SERVICE_ROOT="$PLUGIN_DATA_ROOT/$SERVICE"
   local SERVICE_NAME="$(get_service_name "$SERVICE")"
-  local ID=$(docker ps -aq --no-trunc --filter "name=^/$SERVICE_NAME$" --format '{{ .ID }}') || true
-  [[ -z $ID ]] && dokku_log_warn "Service is already stopped" && return 0
+  local ID=$("$DOCKER_BIN" container ps -aq --no-trunc --filter "name=^/$SERVICE_NAME$") || true
+  [[ -z $ID ]] && dokku_log_warn "Service is already paused" && return 0
 
   if [[ -n $ID ]]; then
-    dokku_log_info2_quiet "Stopping container"
-    docker stop "$SERVICE_NAME" >/dev/null
-    service_port_pause "$SERVICE"
-    dokku_log_verbose_quiet "Container stopped"
+    dokku_log_info2_quiet "Pausing container"
+    "$DOCKER_BIN" container stop "$SERVICE_NAME" >/dev/null
+    if "$DOCKER_BIN" container inspect "$ID" >/dev/null 2>&1; then
+      "$DOCKER_BIN" container stop "$SERVICE_NAME.ambassador" >/dev/null 2>&1 || true
+    fi
+    dokku_log_verbose_quiet "Container paused"
   else
     dokku_log_verbose_quiet "No container exists for $SERVICE"
   fi
 }
 
 service_unlink() {
-  declare desc="Unlinks an application from a service"
+  declare desc="unlink an application from a service"
   declare SERVICE="$1" APP="$2"
   update_plugin_scheme_for_app "$APP"
   local SERVICE_URL=$(service_url "$SERVICE")
@@ -770,6 +987,7 @@ service_unlink() {
   local SERVICE_DNS_HOSTNAME=$(service_dns_hostname "$SERVICE")
   local LINK=($(echo "$EXISTING_CONFIG" | grep "$SERVICE_URL" | cut -d: -f1)) || true
 
+  plugn trigger service-action pre-unlink "$PLUGIN_COMMAND_PREFIX" "$SERVICE" "$APP"
   remove_from_links_file "$SERVICE" "$APP"
 
   if declare -f -F add_passed_docker_option >/dev/null; then
@@ -781,18 +999,25 @@ service_unlink() {
   fi
 
   [[ -z ${LINK[*]} ]] && dokku_log_fail "Not linked to app $APP"
-  config_unset "$APP" "${LINK[*]}"
+  plugn trigger service-action post-unlink "$PLUGIN_COMMAND_PREFIX" "$SERVICE" "$APP"
+  if [[ "$DOKKU_GLOBAL_FLAGS" == *"--no-restart"* ]] || [[ "$SERVICE_RESTART_APPS" == "false" ]]; then
+    config_unset --no-restart "$APP" "${LINK[@]}"
+    dokku_log_verbose "Skipping restart of linked app"
+  else
+    config_unset "$APP" "${LINK[@]}"
+  fi
+  plugn trigger service-action post-unlink-complete "$PLUGIN_COMMAND_PREFIX" "$SERVICE" "$APP"
 }
 
 service_version() {
-  declare desc="Displays the running version for an image"
+  declare desc="display the running version for an image"
   declare SERVICE="$1"
   local SERVICE_NAME="$(get_service_name "$SERVICE")"
-  docker inspect -f '{{.Config.Image}}' "$SERVICE_NAME" 2>/dev/null || true
+  "$DOCKER_BIN" container inspect -f '{{.Config.Image}}' "$SERVICE_NAME" 2>/dev/null || true
 }
 
 update_plugin_scheme_for_app() {
-  declare desc="Retrieves the updated plugin scheme"
+  declare desc="retrieve the updated plugin scheme"
   declare APP="$1"
   local DATABASE_SCHEME
 
@@ -801,19 +1026,31 @@ update_plugin_scheme_for_app() {
 }
 
 verify_service_name() {
-  declare desc="Verifies that a service exists"
-  declare SERVICE="$1"
-  [[ -z "$SERVICE" ]] && dokku_log_fail "(verify_service_name) SERVICE must not be null"
-  [[ ! -d "$PLUGIN_DATA_ROOT/$SERVICE" ]] && dokku_log_fail "$PLUGIN_SERVICE service $SERVICE does not exist"
+  declare desc="verify that a service exists"
+  declare SERVICE="$@"
+
+  if [[ -z "$SERVICE" ]]; then
+    dokku_log_fail "SERVICE must not be empty"
+  fi
+
+  if [[ ! -d "$PLUGIN_DATA_ROOT/$SERVICE" ]]; then
+    dokku_log_fail "$PLUGIN_SERVICE service $SERVICE does not exist"
+  fi
+
+  SERVICE="$(auth_service_filter "$SERVICE")"
+  if [[ -z "$SERVICE" ]]; then
+    dokku_log_fail "$PLUGIN_SERVICE service $SERVICE does not exist"
+  fi
+
   return 0
 }
 
 write_database_name() {
-  declare desc="Writes a sanitized database name"
+  declare desc="write a sanitized database name"
   declare SERVICE="$1"
   local SERVICE_ROOT="$PLUGIN_DATA_ROOT/$SERVICE"
 
   # some datastores do not like special characters in database names
   # so we need to normalize them out
-  echo "$SERVICE" | tr .- _ > "$SERVICE_ROOT/DATABASE_NAME"
+  echo "$SERVICE" | tr .- _ >"$SERVICE_ROOT/DATABASE_NAME"
 }

config

@@ -1,8 +1,10 @@
 #!/usr/bin/env bash
-export MONGO_IMAGE=${MONGO_IMAGE:="mongo"}
-export MONGO_IMAGE_VERSION=${MONGO_IMAGE_VERSION:="3.6.15"}
+_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+export MONGO_IMAGE=${MONGO_IMAGE:="$(awk -F '[ :]' '{print $2}' "${_DIR}/Dockerfile")"}
+export MONGO_IMAGE_VERSION=${MONGO_IMAGE_VERSION:="$(awk -F '[ :]' '{print $3}' "${_DIR}/Dockerfile")"}
 export MONGO_ROOT=${MONGO_ROOT:="$DOKKU_LIB_ROOT/services/mongo"}
-export MONGO_HOST_ROOT=${MONGO_HOST_ROOT:=$MONGO_ROOT}
+export DOKKU_LIB_HOST_ROOT=${DOKKU_LIB_HOST_ROOT:=$DOKKU_LIB_ROOT}
+export MONGO_HOST_ROOT=${MONGO_HOST_ROOT:="$DOKKU_LIB_HOST_ROOT/services/mongo"}
 
 export PLUGIN_UNIMPLEMENTED_SUBCOMMANDS=()
 export PLUGIN_COMMAND_PREFIX="mongo"
@@ -21,8 +23,14 @@ export PLUGIN_SCHEME="mongodb"
 export PLUGIN_SERVICE="MongoDB"
 export PLUGIN_VARIABLE="MONGO"
 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=${PLUGIN_BUSYBOX_IMAGE:=busybox:1.37.0-uclibc}
+export PLUGIN_AMBASSADOR_IMAGE=${PLUGIN_AMBASSADOR_IMAGE:=dokku/ambassador:0.8.2}
+export PLUGIN_S3BACKUP_IMAGE=${PLUGIN_S3BACKUP_IMAGE:=dokku/s3backup:0.18.0}
+export PLUGIN_WAIT_IMAGE=${PLUGIN_WAIT_IMAGE:=dokku/wait:0.9.3}
+
 export MONGO_CONFIG_OPTIONS=${MONGO_CONFIG_OPTIONS:=" --storageEngine wiredTiger --auth "}

docs/README.md

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

functions

@@ -3,7 +3,8 @@ source "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/config"
 set -eo pipefail
 [[ $DOKKU_TRACE ]] && set -x
 source "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/common-functions"
-source "$PLUGIN_BASE_PATH/common/functions"
+source "$PLUGIN_CORE_AVAILABLE_PATH/common/functions"
+source "$PLUGIN_CORE_AVAILABLE_PATH/common/property-functions"
 source "$PLUGIN_AVAILABLE_PATH/config/functions"
 if [[ -f "$PLUGIN_AVAILABLE_PATH/docker-options/functions" ]]; then
   source "$PLUGIN_AVAILABLE_PATH/docker-options/functions"
@@ -18,7 +19,7 @@ service_connect() {
   local SERVICE_TTY_OPTS
   has_tty && SERVICE_TTY_OPTS="-t"
 
-  docker exec -i $SERVICE_TTY_OPTS "$SERVICE_NAME" mongo -u "$SERVICE" -p "$PASSWORD" --authenticationDatabase "$DATABASE_NAME" "$DATABASE_NAME"
+  "$DOCKER_BIN" container exec --env=LANG=C.UTF-8 --env=LC_ALL=C.UTF-8 -i $SERVICE_TTY_OPTS "$SERVICE_NAME" mongosh -u "$SERVICE" -p "$PASSWORD" --authenticationDatabase "$DATABASE_NAME" "$DATABASE_NAME"
 }
 
 service_create() {
@@ -34,16 +35,17 @@ service_create() {
   if ! service_image_exists "$SERVICE"; then
     if [[ "$PLUGIN_DISABLE_PULL" == "true" ]]; then
       dokku_log_warn "${PLUGIN_DISABLE_PULL_VARIABLE} environment variable detected. Not running pull command." 1>&2
-      dokku_log_warn "   docker pull ${IMAGE}" 1>&2
+      dokku_log_warn "   docker image pull ${IMAGE}" 1>&2
       dokku_log_warn "$PLUGIN_SERVICE service creation failed"
       exit 1
     fi
-    docker pull "$PLUGIN_IMAGE:$PLUGIN_IMAGE_VERSION" || dokku_log_fail "$PLUGIN_SERVICE image $PLUGIN_IMAGE:$PLUGIN_IMAGE_VERSION pull failed"
+    "$DOCKER_BIN" image pull "$PLUGIN_IMAGE:$PLUGIN_IMAGE_VERSION" || dokku_log_fail "$PLUGIN_SERVICE image $PLUGIN_IMAGE:$PLUGIN_IMAGE_VERSION pull failed"
   fi
 
+  plugn trigger service-action pre-create "$PLUGIN_COMMAND_PREFIX" "$SERVICE"
   mkdir -p "$SERVICE_ROOT" || dokku_log_fail "Unable to create service directory"
   mkdir -p "$SERVICE_ROOT/data" || dokku_log_fail "Unable to create service data directory"
-  mkdir -p "$SERVICE_ROOT/config" || dokku_log_fail "Unable to create service config directory"
+  mkdir -p "$SERVICE_ROOT/$PLUGIN_CONFIG_SUFFIX" || dokku_log_fail "Unable to create service config directory"
   touch "$LINKS_FILE"
 
   ROOTPASSWORD=$(openssl rand -hex 16)
@@ -60,22 +62,11 @@ service_create() {
   echo "$PASSWORD" >"$SERVICE_ROOT/PASSWORD"
   chmod 640 "$SERVICE_ROOT/ROOTPASSWORD" "$SERVICE_ROOT/PASSWORD"
 
-  [[ -n "$SERVICE_CUSTOM_ENV" ]] && MONGO_CUSTOM_ENV="$SERVICE_CUSTOM_ENV"
-  if [[ -n $MONGO_CUSTOM_ENV ]]; then
-    echo "$MONGO_CUSTOM_ENV" | tr ';' "\n" >"$SERVICE_ROOT/ENV"
-  else
-    echo "" >"$SERVICE_ROOT/ENV"
-  fi
-
-  [[ -n "$PLUGIN_CONFIG_OPTIONS" ]] && MONGO_CONFIG_OPTIONS="$PLUGIN_CONFIG_OPTIONS"
-  if [[ -n "$MONGO_CONFIG_OPTIONS" ]]; then
-    echo "$MONGO_CONFIG_OPTIONS" >"$SERVICE_ROOT/MONGO_CONFIG_OPTIONS"
-  else
-    echo "" >"$SERVICE_ROOT/MONGO_CONFIG_OPTIONS"
-  fi
-
+  service_commit_config "$SERVICE"
   write_database_name "$SERVICE"
+  plugn trigger service-action post-create "$PLUGIN_COMMAND_PREFIX" "$SERVICE"
   service_create_container "$SERVICE"
+  plugn trigger service-action post-create-complete "$PLUGIN_COMMAND_PREFIX" "$SERVICE"
 }
 
 service_create_container() {
@@ -87,19 +78,83 @@ service_create_container() {
   local PASSWORD="$(service_password "$SERVICE")"
   local DATABASE_NAME="$(get_database_name "$SERVICE")"
 
-  if [[ -f "$SERVICE_ROOT/MONGO_CONFIG_OPTIONS" ]]; then
-    export MONGO_CONFIG_OPTIONS="$(cat "$SERVICE_ROOT/MONGO_CONFIG_OPTIONS")"
+  if [[ -f "$SERVICE_ROOT/CONFIG_OPTIONS" ]]; then
+    export CONFIG_OPTIONS="$(cat "$SERVICE_ROOT/CONFIG_OPTIONS")"
+  fi
+
+  local network_alias="$(service_dns_hostname "$SERVICE")"
+
+  rm -f "$SERVICE_ROOT/ID"
+  declare -a DOCKER_ARGS
+  DOCKER_ARGS=()
+  DOCKER_ARGS+=("--cidfile=$SERVICE_ROOT/ID")
+  DOCKER_ARGS+=("--env-file=$SERVICE_ROOT/ENV")
+  DOCKER_ARGS+=("--env=MONGO_INITDB_DATABASE=$DATABASE_NAME")
+  DOCKER_ARGS+=("--env=MONGO_INITDB_ROOT_USERNAME=admin")
+  DOCKER_ARGS+=("--env=MONGO_INITDB_ROOT_PASSWORD=$ROOTPASSWORD")
+  DOCKER_ARGS+=("--hostname=$SERVICE_NAME")
+  DOCKER_ARGS+=("--label=dokku.service=$PLUGIN_COMMAND_PREFIX")
+  DOCKER_ARGS+=("--label=dokku=service")
+  DOCKER_ARGS+=("--name=$SERVICE_NAME")
+  DOCKER_ARGS+=("--restart=always")
+  DOCKER_ARGS+=("--volume=$SERVICE_HOST_ROOT/data:/data/db")
+
+  declare -a LINK_CONTAINER_DOCKER_ARGS
+  LINK_CONTAINER_DOCKER_ARGS=()
+  LINK_CONTAINER_DOCKER_ARGS+=("--rm")
+  LINK_CONTAINER_DOCKER_ARGS+=("--link")
+  LINK_CONTAINER_DOCKER_ARGS+=("$SERVICE_NAME:$network_alias")
+
+  [[ -f "$SERVICE_ROOT/SERVICE_MEMORY" ]] && SERVICE_MEMORY="$(cat "$SERVICE_ROOT/SERVICE_MEMORY")"
+  if [[ -n "$SERVICE_MEMORY" ]]; then
+    DOCKER_ARGS+=("--memory=${SERVICE_MEMORY}m")
+  fi
+
+  [[ -f "$SERVICE_ROOT/SHM_SIZE" ]] && SERVICE_SHM_SIZE="$(cat "$SERVICE_ROOT/SHM_SIZE")"
+  if [[ -n "$SERVICE_SHM_SIZE" ]]; then
+    DOCKER_ARGS+=("--shm-size=${SERVICE_SHM_SIZE}")
+  fi
+
+  [[ -f "$SERVICE_ROOT/IMAGE" ]] && PLUGIN_IMAGE="$(cat "$SERVICE_ROOT/IMAGE")"
+  [[ -f "$SERVICE_ROOT/IMAGE_VERSION" ]] && PLUGIN_IMAGE_VERSION="$(cat "$SERVICE_ROOT/IMAGE_VERSION")"
+
+  local network="$(fn-plugin-property-get "$PLUGIN_COMMAND_PREFIX" "$SERVICE" "initial-network")"
+  if [[ -n "$network" ]]; then
+    DOCKER_ARGS+=("--network=${network}")
+    DOCKER_ARGS+=("--network-alias=${network_alias}")
+    LINK_CONTAINER_DOCKER_ARGS+=("--network=${network}")
   fi
 
   # shellcheck disable=SC2086
-  ID=$(docker run --name "$SERVICE_NAME" -v "$SERVICE_HOST_ROOT/data:/data/db" --env-file="$SERVICE_ROOT/ENV" --env "MONGO_INITDB_DATABASE=$DATABASE_NAME" -d --restart always --label dokku=service --label dokku.service=mongo "$PLUGIN_IMAGE:$PLUGIN_IMAGE_VERSION" mongod $MONGO_CONFIG_OPTIONS)
-  echo "$ID" >"$SERVICE_ROOT/ID"
+  suppress_output "$DOCKER_BIN" container create "${DOCKER_ARGS[@]}" "$PLUGIN_IMAGE:$PLUGIN_IMAGE_VERSION" mongod $CONFIG_OPTIONS
+
+  if [[ -n "$(fn-plugin-property-get "$PLUGIN_COMMAND_PREFIX" "$SERVICE" "post-create-network")" ]]; then
+    dokku_log_verbose_quiet "Connecting to networks after container create"
+    while read -r line || [[ -n "$line" ]]; do
+      dokku_log_verbose_quiet "- $line"
+      "$DOCKER_BIN" network connect --alias "$network_alias" "$line" "$SERVICE_NAME"
+    done < <(fn-plugin-property-get "$PLUGIN_COMMAND_PREFIX" "$SERVICE" "post-create-network" | tr "," "\n")
+  fi
+  suppress_output "$DOCKER_BIN" container start "$(cat "$SERVICE_ROOT/ID")"
+  service_port_reconcile_status "$SERVICE"
+
+  if [[ -n "$(fn-plugin-property-get "$PLUGIN_COMMAND_PREFIX" "$SERVICE" "post-start-network")" ]]; then
+    dokku_log_verbose_quiet "Connecting to networks after container start"
+    while read -r line || [[ -n "$line" ]]; do
+      dokku_log_verbose_quiet "- $line"
+      "$DOCKER_BIN" network connect --alias "$network_alias" "$line" "$SERVICE_NAME"
+    done < <(fn-plugin-property-get "$PLUGIN_COMMAND_PREFIX" "$SERVICE" "post-start-network" | tr "," "\n")
+  fi
 
   dokku_log_verbose_quiet "Waiting for container to be ready"
-  docker run --rm --link "$SERVICE_NAME:$PLUGIN_COMMAND_PREFIX" dokku/wait:0.4.1 -p "$PLUGIN_DATASTORE_WAIT_PORT" >/dev/null
+  if ! suppress_output "$DOCKER_BIN" container run "${LINK_CONTAINER_DOCKER_ARGS[@]}" "$PLUGIN_WAIT_IMAGE" -c "$network_alias:$PLUGIN_DATASTORE_WAIT_PORT"; then
+    dokku_log_info2_quiet "Start of $SERVICE container output"
+    dokku_container_log_verbose_quiet "$SERVICE_NAME"
+    dokku_log_info2_quiet "End of $SERVICE container output"
+    return 1
+  fi
 
-  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
+  "$DOCKER_BIN" container exec -i "$SERVICE_NAME" mongosh -u admin -p "$ROOTPASSWORD" --authenticationDatabase admin "$DATABASE_NAME" --eval "if (db.getUser('$SERVICE') == null) { db.createUser({user:'$SERVICE',pwd:'$PASSWORD',roles:[{role:'readWrite',db:'$DATABASE_NAME'}]}) }" >/dev/null
   dokku_log_info2 "$PLUGIN_SERVICE container created: $SERVICE"
   service_info "$SERVICE"
 }
@@ -112,7 +167,7 @@ service_export() {
   local PASSWORD="$(service_password "$SERVICE")"
 
   [[ -n $SSH_TTY ]] && stty -opost
-  docker exec "$SERVICE_NAME" bash -c "mongodump -d $DATABASE_NAME -u \"$SERVICE\" -p \"$PASSWORD\" --authenticationDatabase \"$DATABASE_NAME\" --quiet --gzip --archive 2>/dev/null"
+  "$DOCKER_BIN" container exec "$SERVICE_NAME" bash -c "mongodump -d $DATABASE_NAME -u \"$SERVICE\" -p \"$PASSWORD\" --authenticationDatabase \"$DATABASE_NAME\" --quiet --gzip --archive 2>/dev/null"
   status=$?
   [[ -n $SSH_TTY ]] && stty opost
   exit $status
@@ -129,7 +184,7 @@ service_import() {
   if [[ -t 0 ]]; then
     dokku_log_fail "No data provided on stdin."
   fi
-  docker exec -i "$SERVICE_NAME" bash -c "mongorestore -u \"$SERVICE\" -p \"$PASSWORD\" --authenticationDatabase \"$DATABASE_NAME\" --gzip --archive --nsFrom '\$db\$.\$coll\$' --nsTo '$DATABASE_NAME.\$coll\$'"
+  "$DOCKER_BIN" container exec -i "$SERVICE_NAME" bash -c "mongorestore -u \"$SERVICE\" -p \"$PASSWORD\" --authenticationDatabase \"$DATABASE_NAME\" --gzip --archive --nsFrom '\$db\$.\$coll\$' --nsTo '$DATABASE_NAME.\$coll\$'"
 }
 
 service_start() {
@@ -137,7 +192,7 @@ service_start() {
   local QUIET="$2"
   local SERVICE_ROOT="$PLUGIN_DATA_ROOT/$SERVICE"
   local SERVICE_NAME="$(get_service_name "$SERVICE")"
-  local ID=$(docker ps -aq --no-trunc --filter "status=running" --filter "name=^/$SERVICE_NAME$" --format '{{ .ID }}') || true
+  local ID=$("$DOCKER_BIN" container ps -aq --no-trunc --filter "status=running" --filter "name=^/$SERVICE_NAME$") || true
   if [[ -n $ID ]]; then
     [[ -z $QUIET ]] && dokku_log_warn "Service is already started"
     if [[ ! -f "$SERVICE_ROOT/ID" ]] || [[ "$(cat "$SERVICE_ROOT/ID")" != "$ID" ]]; then
@@ -148,18 +203,24 @@ service_start() {
   fi
 
   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 PREVIOUS_ID=$("$DOCKER_BIN" container ps -aq --no-trunc --filter "status=exited" --filter "name=^/$SERVICE_NAME$") || true
   local ROOTPASSWORD="$(service_root_password "$SERVICE")"
   local PASSWORD="$(service_password "$SERVICE")"
 
   if [[ -n $PREVIOUS_ID ]]; then
-    docker start "$PREVIOUS_ID" >/dev/null
-    service_port_unpause "$SERVICE"
+    "$DOCKER_BIN" container start "$PREVIOUS_ID" >/dev/null
+    service_port_reconcile_status "$SERVICE"
     dokku_log_info2 "Container started"
   elif service_image_exists "$SERVICE" && [[ -n "$ROOTPASSWORD" ]] && [[ -n "$PASSWORD" ]]; then
     service_create_container "$SERVICE"
   else
-    dokku_log_verbose_quiet "Neither container nor valid configuration exists for $SERVICE"
+    if ! service_image_exists "$SERVICE"; then
+      [[ -f "$SERVICE_ROOT/IMAGE" ]] && PLUGIN_IMAGE="$(cat "$SERVICE_ROOT/IMAGE")"
+      [[ -f "$SERVICE_ROOT/IMAGE_VERSION" ]] && PLUGIN_IMAGE_VERSION="$(cat "$SERVICE_ROOT/IMAGE_VERSION")"
+      dokku_log_verbose_quiet "Missing image $PLUGIN_IMAGE:$PLUGIN_IMAGE_VERSION for $SERVICE"
+    else
+      dokku_log_verbose_quiet "Neither container nor valid configuration exists for $SERVICE"
+    fi
   fi
 }
 

help-functions

@@ -76,10 +76,10 @@ fn-help-contents() {
 
 fn-help-contents-subcommand() {
   declare SUBCOMMAND="$1" FULL_OUTPUT="$2"
-  local TMPDIR=$(mktemp -d)
-  local UNCLEAN_FILE="${TMPDIR}/cmd-unclean" CLEAN_FILE="${TMPDIR}/cmd-clean"
+  local HELP_TMPDIR=$(mktemp -d --tmpdir)
+  local UNCLEAN_FILE="${HELP_TMPDIR}/cmd-unclean" CLEAN_FILE="${HELP_TMPDIR}/cmd-clean"
   local BOLD CMD_OUTPUT CYAN EXAMPLE LIGHT_GRAY NORMAL
-  trap 'rm -rf "$TMPDIR" > /dev/null' RETURN INT TERM EXIT
+  trap 'rm -rf "$HELP_TMPDIR" > /dev/null' RETURN INT TERM EXIT
 
   rm -rf "$UNCLEAN_FILE" "$CLEAN_FILE"
   cat "$SUBCOMMAND_ROOT/$SUBCOMMAND" >"$UNCLEAN_FILE"
@@ -141,7 +141,7 @@ fn-help-contents-subcommand() {
 }
 
 fn-help-fancy-tput() {
-  declare desc="A wrapper around tput"
+  declare desc="a wrapper around tput"
 
   if [[ -n "$DOKKU_NO_COLOR" ]] || [[ "$TERM" == "unknown" ]] || [[ "$TERM" == "dumb" ]]; then
     return
@@ -151,7 +151,7 @@ fn-help-fancy-tput() {
 }
 
 fn-help-fancy-color() {
-  declare desc="A wrapper around colors"
+  declare desc="a wrapper around colors"
 
   if [[ -n "$DOKKU_NO_COLOR" ]] || [[ "$TERM" == "unknown" ]] || [[ "$TERM" == "dumb" ]]; then
     return
@@ -164,8 +164,8 @@ fn-help-list-example() {
   # shellcheck disable=SC2034
   declare desc="return $PLUGIN_COMMAND_PREFIX plugin help content"
   cat <<help_list
-      NAME, VERSION, STATUS, EXPOSED PORTS, LINKS
-      service-name, $PLUGIN_COMMAND_PREFIX:$PLUGIN_IMAGE_VERSION, running, -, app-name
+      $PLUGIN_SERVICE services
+      service-name
 help_list
 }
 
@@ -191,7 +191,7 @@ fn-help-subcommand-args() {
     if [[ "$arg" == *_FLAG ]]; then
       arg="${arg/_FLAG/}"
       if [[ $arg == "INFO" ]]; then
-        arg="SINGLE_INFO_FLAG..."
+        arg="SINGLE_INFO_FLAG"
         args+=" ${BLUE}[--${arg//_/-}]${NORMAL}"
       else
         args+=" ${BLUE}[-${arg:0:1}|--${arg//_/-}]${NORMAL}"
@@ -202,6 +202,9 @@ fn-help-subcommand-args() {
     elif [[ "$arg" == *_LIST ]]; then
       arg=${arg%_*}
       args+=" <${arg//_/-}...>"
+    elif [[ "$arg" == *_OPTIONAL ]]; then
+      argName="${arg/_OPTIONAL/}"
+      args+=" [<${argName//_/-}>]"
     else
       args+=" <${arg//_/-}>"
     fi
@@ -309,7 +312,7 @@ fn-help-subcommand-sanitize() {
 }
 
 _fn-help-apply-shell-expansion() {
-  declare desc="Expand environment variables for a shell command"
+  declare desc="expand environment variables for a shell command"
   declare data="$1"
   declare delimiter="__apply_shell_expansion_delimiter__"
   declare command="cat <<$delimiter"$'\n'"$data"$'\n'"$delimiter"

install

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

plugin.toml

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

post-app-clone-setup

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

post-app-rename-setup

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

pre-delete

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

pre-restore

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

pre-start

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

service-list

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

subcommands/app-links

@@ -2,7 +2,7 @@
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/config"
 set -eo pipefail
 [[ $DOKKU_TRACE ]] && set -x
-source "$PLUGIN_BASE_PATH/common/functions"
+source "$PLUGIN_CORE_AVAILABLE_PATH/common/functions"
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/functions"
 
 service-app-links-cmd() {

subcommands/backup

@@ -2,16 +2,18 @@
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/config"
 set -eo pipefail
 [[ $DOKKU_TRACE ]] && set -x
-source "$PLUGIN_BASE_PATH/common/functions"
+source "$PLUGIN_CORE_AVAILABLE_PATH/common/functions"
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/functions"
 
 service-backup-cmd() {
-  #E backup the 'lolipop' service to the 'my-s3-bucket' bucket on AWS
-  #E dokku $PLUGIN_COMMAND_PREFIX:backup lolipop my-s3-bucket --use-iam
+  #E backup the 'lollipop' service to the 'my-s3-bucket' bucket on AWS
+  #E dokku $PLUGIN_COMMAND_PREFIX:backup lollipop my-s3-bucket --use-iam
+  #E restore a backup file (assuming it was extracted via 'tar -xf backup.tgz')
+  #E dokku $PLUGIN_COMMAND_PREFIX:import lollipop < backup-folder/export
   #F -u|--use-iam, use the IAM profile associated with the current server
   #A service, service to run command against
   #A bucket-name, name of the s3 bucket to upload backups to
-  declare desc="creates a backup of the $PLUGIN_SERVICE service to an existing s3 bucket"
+  declare desc="create a backup of the $PLUGIN_SERVICE service to an existing s3 bucket"
   local cmd="$PLUGIN_COMMAND_PREFIX:backup" argv=("$@")
   [[ ${argv[0]} == "$cmd" ]] && shift 1
   declare SERVICE="$1" BUCKET_NAME="$2" USE_IAM_OPTIONAL_FLAG="$3"

subcommands/backup-auth

@@ -2,25 +2,25 @@
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/config"
 set -eo pipefail
 [[ $DOKKU_TRACE ]] && set -x
-source "$PLUGIN_BASE_PATH/common/functions"
+source "$PLUGIN_CORE_AVAILABLE_PATH/common/functions"
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/functions"
 
 service-backup-auth-cmd() {
   #E setup s3 backup authentication
-  #E dokku $PLUGIN_COMMAND_PREFIX:backup-auth lolipop AWS_ACCESS_KEY_ID AWS_SECRET_ACCESS_KEY
+  #E dokku $PLUGIN_COMMAND_PREFIX:backup-auth lollipop AWS_ACCESS_KEY_ID AWS_SECRET_ACCESS_KEY
   #E setup s3 backup authentication with different region
-  #E dokku $PLUGIN_COMMAND_PREFIX:backup-auth lolipop AWS_ACCESS_KEY_ID AWS_SECRET_ACCESS_KEY AWS_REGION
+  #E dokku $PLUGIN_COMMAND_PREFIX:backup-auth lollipop AWS_ACCESS_KEY_ID AWS_SECRET_ACCESS_KEY AWS_REGION
   #E setup s3 backup authentication with different signature version and endpoint
-  #E dokku $PLUGIN_COMMAND_PREFIX:backup-auth lolipop AWS_ACCESS_KEY_ID AWS_SECRET_ACCESS_KEY AWS_REGION AWS_SIGNATURE_VERSION ENDPOINT_URL
+  #E dokku $PLUGIN_COMMAND_PREFIX:backup-auth lollipop AWS_ACCESS_KEY_ID AWS_SECRET_ACCESS_KEY AWS_REGION AWS_SIGNATURE_VERSION ENDPOINT_URL
   #E more specific example for minio auth
-  #E dokku $PLUGIN_COMMAND_PREFIX:backup-auth lolipop MINIO_ACCESS_KEY_ID MINIO_SECRET_ACCESS_KEY us-east-1 s3v4 https://YOURMINIOSERVICE
+  #E dokku $PLUGIN_COMMAND_PREFIX:backup-auth lollipop MINIO_ACCESS_KEY_ID MINIO_SECRET_ACCESS_KEY us-east-1 s3v4 https://YOURMINIOSERVICE
   #A service, service to run command against
   #A access-key-id, an amazon AWS_ACCESS_KEY_ID
   #A aws-secret-access-key, an amazon AWS_SECRET_ACCESS_KEY
   #A aws-default-region, (optional) a valid amazon S3 region
   #A aws-signature-version, (optional) the AWS signature version to use when signing S3 requests
   #A endpoint-url, (optional) an aws endpoint to upload to
-  declare desc="sets up authentication for backups on the $PLUGIN_SERVICE service"
+  declare desc="set up authentication for backups on the $PLUGIN_SERVICE service"
   local cmd="$PLUGIN_COMMAND_PREFIX:backup-auth" argv=("$@")
   [[ ${argv[0]} == "$cmd" ]] && shift 1
   declare SERVICE="$1" AWS_ACCESS_KEY_ID="$2" AWS_SECRET_ACCESS_KEY="$3" AWS_DEFAULT_REGION="$4" AWS_SIGNATURE_VERSION="$5" ENDPOINT_URL="$6"

subcommands/backup-deauth

@@ -2,14 +2,14 @@
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/config"
 set -eo pipefail
 [[ $DOKKU_TRACE ]] && set -x
-source "$PLUGIN_BASE_PATH/common/functions"
+source "$PLUGIN_CORE_AVAILABLE_PATH/common/functions"
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/functions"
 
 service-backup-deauth-cmd() {
   #E remove s3 authentication
-  #E dokku $PLUGIN_COMMAND_PREFIX:backup-deauth lolipop
+  #E dokku $PLUGIN_COMMAND_PREFIX:backup-deauth lollipop
   #A service, service to run command against
-  declare desc="removes backup authentication for the $PLUGIN_SERVICE service"
+  declare desc="remove backup authentication for the $PLUGIN_SERVICE service"
   local cmd="$PLUGIN_COMMAND_PREFIX:backup-deauth" argv=("$@")
   [[ ${argv[0]} == "$cmd" ]] && shift 1
   declare SERVICE="$1"

subcommands/backup-schedule

@@ -2,20 +2,20 @@
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/config"
 set -eo pipefail
 [[ $DOKKU_TRACE ]] && set -x
-source "$PLUGIN_BASE_PATH/common/functions"
+source "$PLUGIN_CORE_AVAILABLE_PATH/common/functions"
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/functions"
 
 service-backup-schedule-cmd() {
   #E schedule a backup
   #E > 'schedule' is a crontab expression, eg. "0 3 * * *" for each day at 3am
-  #E dokku $PLUGIN_COMMAND_PREFIX:backup-schedule lolipop "0 3 * * *" my-s3-bucket
+  #E dokku $PLUGIN_COMMAND_PREFIX:backup-schedule lollipop "0 3 * * *" my-s3-bucket
   #E schedule a backup and authenticate via iam
-  #E dokku $PLUGIN_COMMAND_PREFIX:backup-schedule lolipop "0 3 * * *" my-s3-bucket --use-iam
+  #E dokku $PLUGIN_COMMAND_PREFIX:backup-schedule lollipop "0 3 * * *" my-s3-bucket --use-iam
   #F -u|--use-iam, use the IAM profile associated with the current server
   #A service, service to run command against
   #A schedule, a cron schedule to run backups on
   #A bucket-name, name of the s3 bucket to upload backups to
-  declare desc="schedules a backup of the $PLUGIN_SERVICE service"
+  declare desc="schedule a backup of the $PLUGIN_SERVICE service"
   local cmd="$PLUGIN_COMMAND_PREFIX:backup-schedule" argv=("$@")
   [[ ${argv[0]} == "$cmd" ]] && shift 1
   declare SERVICE="$1" SCHEDULE="$2" BUCKET_NAME="$3" USE_IAM_OPTIONAL_FLAG="$4"

subcommands/backup-schedule-cat

@@ -2,12 +2,12 @@
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/config"
 set -eo pipefail
 [[ $DOKKU_TRACE ]] && set -x
-source "$PLUGIN_BASE_PATH/common/functions"
+source "$PLUGIN_CORE_AVAILABLE_PATH/common/functions"
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/functions"
 
 service-backup-schedule-cat-cmd() {
   #E cat the contents of the configured backup cronfile for the service
-  #E dokku $PLUGIN_COMMAND_PREFIX:backup-schedule-cat lolipop
+  #E dokku $PLUGIN_COMMAND_PREFIX:backup-schedule-cat lollipop
   #A service, service to run command against
   declare desc="cat the contents of the configured backup cronfile for the service"
   local cmd="$PLUGIN_COMMAND_PREFIX:backup-schedule-cat" argv=("$@")

subcommands/backup-set-encryption

@@ -2,15 +2,15 @@
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/config"
 set -eo pipefail
 [[ $DOKKU_TRACE ]] && set -x
-source "$PLUGIN_BASE_PATH/common/functions"
+source "$PLUGIN_CORE_AVAILABLE_PATH/common/functions"
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/functions"
 
 service-backup-set-encryption-cmd() {
-  #E set a GPG passphrase for backups
-  #E dokku $PLUGIN_COMMAND_PREFIX:backup-set-encryption lolipop
+  #E set the GPG-compatible passphrase for encrypting backups for backups
+  #E dokku $PLUGIN_COMMAND_PREFIX:backup-set-encryption lollipop
   #A service, service to run command against
   #A passphrase, a GPG-compatible passphrase
-  declare desc="sets encryption for all future backups of $PLUGIN_SERVICE service"
+  declare desc="set encryption for all future backups of $PLUGIN_SERVICE service"
   local cmd="$PLUGIN_COMMAND_PREFIX:backup-set-encryption" argv=("$@")
   [[ ${argv[0]} == "$cmd" ]] && shift 1
   declare SERVICE="$1" PASSPHRASE="$2"

subcommands/backup-set-public-key-encryption

@@ -0,0 +1,25 @@
+#!/usr/bin/env bash
+source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/config"
+set -eo pipefail
+[[ $DOKKU_TRACE ]] && set -x
+source "$PLUGIN_CORE_AVAILABLE_PATH/common/functions"
+source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/functions"
+
+service-backup-set-public-key-encryption-cmd() {
+  #E set the GPG Public Key for encrypting backups
+  #E dokku $PLUGIN_COMMAND_PREFIX:backup-set-public-key-encryption lollipop
+  #A service, service to run command against
+  #A public-key-id, a GPG Public Key ID (or fingerprint) to use for encryption. Must be uploaded to the GPG keyserver beforehand.
+  declare desc="set GPG Public Key encryption for all future backups of $PLUGIN_SERVICE service"
+  local cmd="$PLUGIN_COMMAND_PREFIX:backup-set-public-key-encryption" argv=("$@")
+  [[ ${argv[0]} == "$cmd" ]] && shift 1
+  declare SERVICE="$1" PUBLIC_KEY_ID="$2"
+  is_implemented_command "$cmd" || dokku_log_fail "Not yet implemented"
+
+  [[ -z "$SERVICE" ]] && dokku_log_fail "Please specify a valid name for the service"
+  [[ -z "$PUBLIC_KEY_ID" ]] && dokku_log_fail "Please specify a valid GPG Public Key ID (or fingerprint)"
+  verify_service_name "$SERVICE"
+  service_backup_set_public_key_encryption "$SERVICE" "$PUBLIC_KEY_ID"
+}
+
+service-backup-set-public-key-encryption-cmd "$@"

subcommands/backup-unschedule

@@ -2,14 +2,14 @@
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/config"
 set -eo pipefail
 [[ $DOKKU_TRACE ]] && set -x
-source "$PLUGIN_BASE_PATH/common/functions"
+source "$PLUGIN_CORE_AVAILABLE_PATH/common/functions"
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/functions"
 
 service-backup-unschedule-cmd() {
   #E remove the scheduled backup from cron
-  #E dokku $PLUGIN_COMMAND_PREFIX:backup-unschedule lolipop
+  #E dokku $PLUGIN_COMMAND_PREFIX:backup-unschedule lollipop
   #A service, service to run command against
-  declare desc="unschedules the backup of the $PLUGIN_SERVICE service"
+  declare desc="unschedule the backup of the $PLUGIN_SERVICE service"
   local cmd="$PLUGIN_COMMAND_PREFIX:backup-unschedule" argv=("$@")
   [[ ${argv[0]} == "$cmd" ]] && shift 1
   declare SERVICE="$1"

subcommands/backup-unset-encryption

@@ -2,14 +2,14 @@
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/config"
 set -eo pipefail
 [[ $DOKKU_TRACE ]] && set -x
-source "$PLUGIN_BASE_PATH/common/functions"
+source "$PLUGIN_CORE_AVAILABLE_PATH/common/functions"
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/functions"
 
 service-backup-unset-encryption-cmd() {
-  #E unset a GPG encryption key for backups
-  #E dokku $PLUGIN_COMMAND_PREFIX:backup-unset-encryption lolipop
+  #E unset the GPG encryption passphrase for backups
+  #E dokku $PLUGIN_COMMAND_PREFIX:backup-unset-encryption lollipop
   #A service, service to run command against
-  declare desc="unsets encryption for future backups of the $PLUGIN_SERVICE service"
+  declare desc="unset encryption for future backups of the $PLUGIN_SERVICE service"
   local cmd="$PLUGIN_COMMAND_PREFIX:backup-unset-encryption" argv=("$@")
   [[ ${argv[0]} == "$cmd" ]] && shift 1
   declare SERVICE="$1"

subcommands/backup-unset-public-key-encryption

@@ -0,0 +1,23 @@
+#!/usr/bin/env bash
+source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/config"
+set -eo pipefail
+[[ $DOKKU_TRACE ]] && set -x
+source "$PLUGIN_CORE_AVAILABLE_PATH/common/functions"
+source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/functions"
+
+service-backup-unset-public-key-encryption-cmd() {
+  #E unset the GPG Public Key encryption for backups
+  #E dokku $PLUGIN_COMMAND_PREFIX:backup-unset-public-key-encryption lollipop
+  #A service, service to run command against
+  declare desc="unset GPG Public Key encryption for future backups of the $PLUGIN_SERVICE service"
+  local cmd="$PLUGIN_COMMAND_PREFIX:backup-unset-public-key-encryption" argv=("$@")
+  [[ ${argv[0]} == "$cmd" ]] && shift 1
+  declare SERVICE="$1"
+  is_implemented_command "$cmd" || dokku_log_fail "Not yet implemented"  # TODO: [22.03.2024 by Mykola]
+
+  [[ -z "$SERVICE" ]] && dokku_log_fail "Please specify a valid name for the service"
+  verify_service_name "$SERVICE"
+  service_backup_unset_public_key_encryption "$SERVICE"  # TODO: [22.03.2024 by Mykola]
+}
+
+service-backup-unset-encryption-cmd "$@"

subcommands/clone

@@ -2,19 +2,25 @@
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/config"
 set -eo pipefail
 [[ $DOKKU_TRACE ]] && set -x
-source "$PLUGIN_BASE_PATH/common/functions"
+source "$PLUGIN_CORE_AVAILABLE_PATH/common/functions"
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/functions"
 
 service-clone-cmd() {
   #E you can clone an existing service to a new one
-  #E dokku $PLUGIN_COMMAND_PREFIX:clone lolipop lolipop-2
+  #E dokku $PLUGIN_COMMAND_PREFIX:clone lollipop lollipop-2
   #A service, service to run command against
   #A new-service, name of new service
+  #F -c|--config-options "--args --go=here", extra arguments to pass to the container create command
   #F -C|--custom-env "USER=alpha;HOST=beta", semi-colon delimited environment variables to start the service with
   #F -i|--image IMAGE, the image name to start the service with
   #F -I|--image-version IMAGE_VERSION, the image version to start the service with
+  #F -m|--memory MEMORY, container memory limit in megabytes (default: unlimited)
+  #F -N|--initial-network INITIAL_NETWORK, the initial network to attach the service to
   #F -p|--password PASSWORD, override the user-level service password
+  #F -P|--post-create-network NETWORKS, a comma-separated list of networks to attach the service container to after service creation
   #F -r|--root-password PASSWORD, override the root-level service password
+  #F -S|--post-start-network NETWORKS, a comma-separated list of networks to attach the service container to after service start
+  #F -s|--shm-size SHM_SIZE, override shared memory size for $PLUGIN_COMMAND_PREFIX docker container
   declare desc="create container <new-name> then copy data from <name> into <new-name>"
   local cmd="$PLUGIN_COMMAND_PREFIX:clone" argv=("$@")
   [[ ${argv[0]} == "$cmd" ]] && shift 1
@@ -24,6 +30,9 @@ service-clone-cmd() {
   [[ -z "$SERVICE" ]] && dokku_log_fail "Please specify a valid name for the service"
   [[ -z "$NEW_SERVICE" ]] && dokku_log_fail "Please specify a name for the new service"
   verify_service_name "$SERVICE"
+  if service_exists "$NEW_SERVICE"; then
+    dokku_log_fail "Invalid service name $NEW_SERVICE. Verify the service name is not already in use."
+  fi
 
   local SERVICE_ROOT="$PLUGIN_DATA_ROOT/$SERVICE"
   local ID="$(cat "$SERVICE_ROOT/ID")"

subcommands/connect

@@ -2,12 +2,13 @@
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/config"
 set -eo pipefail
 [[ $DOKKU_TRACE ]] && set -x
-source "$PLUGIN_BASE_PATH/common/functions"
+source "$PLUGIN_CORE_AVAILABLE_PATH/common/functions"
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/functions"
 
 service-connect-cmd() {
   #E connect to the service via the $PLUGIN_COMMAND_PREFIX connection tool
-  #E dokku $PLUGIN_COMMAND_PREFIX:connect lolipop
+  #E > NOTE: disconnecting from ssh while running this command may leave zombie processes due to moby/moby#9098
+  #E dokku $PLUGIN_COMMAND_PREFIX:connect lollipop
   #A service, service to run command against
   declare desc="connect to the service via the $PLUGIN_COMMAND_PREFIX connection tool"
   local cmd="$PLUGIN_COMMAND_PREFIX:connect" argv=("$@")

subcommands/connect-admin

@@ -2,12 +2,12 @@
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/config"
 set -eo pipefail
 [[ $DOKKU_TRACE ]] && set -x
-source "$PLUGIN_BASE_PATH/common/functions"
+source "$PLUGIN_CORE_AVAILABLE_PATH/common/functions"
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/functions"
 
 service-connect-admin-cmd() {
   #E connect with the admin user to the service via the $PLUGIN_COMMAND_PREFIX connection tool
-  #E dokku $PLUGIN_COMMAND_PREFIX:connect-admin lolipop
+  #E dokku $PLUGIN_COMMAND_PREFIX:connect-admin lollipop
   #A service, service to run command against
   declare desc="connect via mongo to a $PLUGIN_SERVICE service as admin user"
   local cmd="$PLUGIN_COMMAND_PREFIX:connect-admin" argv=("$@")
@@ -21,7 +21,7 @@ service-connect-admin-cmd() {
   PASSWORD="$(service_root_password "$SERVICE")"
   has_tty && SERVICE_TTY_OPTS="-t"
 
-  docker exec -i $SERVICE_TTY_OPTS "$SERVICE_NAME" mongo -u admin -p "$PASSWORD" --authenticationDatabase admin "$SERVICE"
+  docker exec --env=LANG=C.UTF-8 --env=LC_ALL=C.UTF-8 -i $SERVICE_TTY_OPTS "$SERVICE_NAME" mongosh -u admin -p "$PASSWORD" --authenticationDatabase admin "$SERVICE"
 }
 
 service-connect-admin-cmd "$@"

subcommands/create

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

subcommands/destroy

@@ -2,12 +2,12 @@
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/config"
 set -eo pipefail
 [[ $DOKKU_TRACE ]] && set -x
-source "$PLUGIN_BASE_PATH/common/functions"
+source "$PLUGIN_CORE_AVAILABLE_PATH/common/functions"
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/functions"
 
 service-destroy-cmd() {
   #E destroy the service, it's data, and the running container
-  #E dokku $PLUGIN_COMMAND_PREFIX:destroy lolipop
+  #E dokku $PLUGIN_COMMAND_PREFIX:destroy lollipop
   #A service, service to run command against
   #F -f|--force, force destroy without asking for confirmation
   declare desc="delete the $PLUGIN_SERVICE service/data/container if there are no links left"
@@ -41,13 +41,17 @@ service-destroy-cmd() {
   fi
 
   dokku_log_info2_quiet "Deleting $SERVICE"
+  plugn trigger service-action pre-delete "$PLUGIN_COMMAND_PREFIX" "$SERVICE"
   service_backup_unschedule "$SERVICE"
   service_container_rm "$SERVICE"
 
   dokku_log_verbose_quiet "Removing data"
-  docker run --rm -v "$SERVICE_HOST_ROOT/data:/data" -v "$SERVICE_HOST_ROOT/config:/config" busybox:1.31.0-uclibc chmod 777 -R /config /data
+  "$DOCKER_BIN" container run --rm -v "$SERVICE_HOST_ROOT/data:/data" -v "$SERVICE_HOST_ROOT/$PLUGIN_CONFIG_SUFFIX:/config" "$PLUGIN_BUSYBOX_IMAGE" chmod 777 -R /config /data
   rm -rf "$SERVICE_ROOT"
 
+  fn-plugin-property-destroy "$PLUGIN_COMMAND_PREFIX" "$SERVICE"
+
+  plugn trigger service-action post-delete "$PLUGIN_COMMAND_PREFIX" "$SERVICE"
   dokku_log_info2 "$PLUGIN_SERVICE container deleted: $SERVICE"
 }
 

subcommands/enter

@@ -2,22 +2,24 @@
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/config"
 set -eo pipefail
 [[ $DOKKU_TRACE ]] && set -x
-source "$PLUGIN_BASE_PATH/common/functions"
+source "$PLUGIN_CORE_AVAILABLE_PATH/common/functions"
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/functions"
 
 service-enter-cmd() {
   #E a bash prompt can be opened against a running service.
   #E filesystem changes will not be saved to disk.
-  #E dokku $PLUGIN_COMMAND_PREFIX:enter lolipop
+  #E > NOTE: disconnecting from ssh while running this command may leave zombie processes due to moby/moby#9098
+  #E dokku $PLUGIN_COMMAND_PREFIX:enter lollipop
   #E you may also run a command directly against the service.
   #E filesystem changes will not be saved to disk.
-  #E dokku $PLUGIN_COMMAND_PREFIX:enter lolipop touch /tmp/test
+  #E dokku $PLUGIN_COMMAND_PREFIX:enter lollipop touch /tmp/test
   #A service, service to run command against
   declare desc="enter or run a command in a running $PLUGIN_SERVICE service container"
   local cmd="$PLUGIN_COMMAND_PREFIX:enter" argv=("$@")
   [[ ${argv[0]} == "$cmd" ]] && shift 1
   declare SERVICE="$1"
 
+  verify_service_name "$SERVICE"
   dokku_log_info1_quiet "Filesystem changes may not persist after container restarts"
   service_enter "$SERVICE" "${@:2}"
 }

subcommands/exists

@@ -2,12 +2,12 @@
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/config"
 set -eo pipefail
 [[ $DOKKU_TRACE ]] && set -x
-source "$PLUGIN_BASE_PATH/common/functions"
+source "$PLUGIN_CORE_AVAILABLE_PATH/common/functions"
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/functions"
 
 service-exists-cmd() {
-  #E here we check if the lolipop $PLUGIN_COMMAND_PREFIX service exists.
-  #E dokku $PLUGIN_COMMAND_PREFIX:exists lolipop
+  #E here we check if the lollipop $PLUGIN_COMMAND_PREFIX service exists.
+  #E dokku $PLUGIN_COMMAND_PREFIX:exists lollipop
   #A service, service to run command against
   declare desc="check if the $PLUGIN_SERVICE service exists"
   local cmd="$PLUGIN_COMMAND_PREFIX:exists" argv=("$@")

subcommands/export

@@ -2,14 +2,14 @@
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/config"
 set -eo pipefail
 [[ $DOKKU_TRACE ]] && set -x
-source "$PLUGIN_BASE_PATH/common/functions"
+source "$PLUGIN_CORE_AVAILABLE_PATH/common/functions"
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/functions"
 
 service-export-cmd() {
   #E by default, datastore output is exported to stdout
-  #E dokku $PLUGIN_COMMAND_PREFIX:export lolipop
+  #E dokku $PLUGIN_COMMAND_PREFIX:export lollipop
   #E you can redirect this output to a file
-  #E dokku $PLUGIN_COMMAND_PREFIX:export lolipop > lolipop.dump
+  #E dokku $PLUGIN_COMMAND_PREFIX:export lollipop > data.dump
   #A service, service to run command against
   declare desc="export a dump of the $PLUGIN_SERVICE service database"
   local cmd="$PLUGIN_COMMAND_PREFIX:export" argv=("$@")

subcommands/expose

@@ -2,15 +2,17 @@
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/config"
 set -eo pipefail
 [[ $DOKKU_TRACE ]] && set -x
-source "$PLUGIN_BASE_PATH/common/functions"
+source "$PLUGIN_CORE_AVAILABLE_PATH/common/functions"
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/functions"
 
 service-expose-cmd() {
   #E expose the service on the service's normal ports, allowing access to it from the public interface (0.0.0.0)
-  #E dokku $PLUGIN_COMMAND_PREFIX:expose lolipop ${PLUGIN_DATASTORE_PORTS[@]}
+  #E dokku $PLUGIN_COMMAND_PREFIX:expose lollipop ${PLUGIN_DATASTORE_PORTS[@]}
+  #E expose the service on the service's normal ports, with the first on a specified ip address (127.0.0.1)
+  #E dokku $PLUGIN_COMMAND_PREFIX:expose lollipop 127.0.0.1:${PLUGIN_DATASTORE_PORTS[@]}
   #A service, service to run command against
   #A ports, a list of ports to run against
-  declare desc="expose a $PLUGIN_SERVICE service on custom port if provided (random port otherwise)"
+  declare desc="expose a $PLUGIN_SERVICE service on custom host:port if provided (random port on the 0.0.0.0 interface if otherwise unspecified)"
   local cmd="$PLUGIN_COMMAND_PREFIX:expose" argv=("$@")
   [[ ${argv[0]} == "$cmd" ]] && shift 1
   declare SERVICE="$1" PORTS_LIST=("${@:2}")

subcommands/import

@@ -2,12 +2,12 @@
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/config"
 set -eo pipefail
 [[ $DOKKU_TRACE ]] && set -x
-source "$PLUGIN_BASE_PATH/common/functions"
+source "$PLUGIN_CORE_AVAILABLE_PATH/common/functions"
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/functions"
 
 service-import-cmd() {
   #E import a datastore dump
-  #E dokku $PLUGIN_COMMAND_PREFIX:import lolipop < database.dump
+  #E dokku $PLUGIN_COMMAND_PREFIX:import lollipop < data.dump
   #A service, service to run command against
   declare desc="import a dump into the $PLUGIN_SERVICE service database"
   local cmd="$PLUGIN_COMMAND_PREFIX:import" argv=("$@")

subcommands/info

@@ -2,23 +2,26 @@
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/config"
 set -eo pipefail
 [[ $DOKKU_TRACE ]] && set -x
-source "$PLUGIN_BASE_PATH/common/functions"
+source "$PLUGIN_CORE_AVAILABLE_PATH/common/functions"
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/functions"
 
 service-info-cmd() {
   #E get connection information as follows:
-  #E dokku $PLUGIN_COMMAND_PREFIX:info lolipop
+  #E dokku $PLUGIN_COMMAND_PREFIX:info lollipop
   #E you can also retrieve a specific piece of service info via flags:
-  #E dokku $PLUGIN_COMMAND_PREFIX:info lolipop --config-dir
-  #E dokku $PLUGIN_COMMAND_PREFIX:info lolipop --data-dir
-  #E dokku $PLUGIN_COMMAND_PREFIX:info lolipop --dsn
-  #E dokku $PLUGIN_COMMAND_PREFIX:info lolipop --exposed-ports
-  #E dokku $PLUGIN_COMMAND_PREFIX:info lolipop --id
-  #E dokku $PLUGIN_COMMAND_PREFIX:info lolipop --internal-ip
-  #E dokku $PLUGIN_COMMAND_PREFIX:info lolipop --links
-  #E dokku $PLUGIN_COMMAND_PREFIX:info lolipop --service-root
-  #E dokku $PLUGIN_COMMAND_PREFIX:info lolipop --status
-  #E dokku $PLUGIN_COMMAND_PREFIX:info lolipop --version
+  #E dokku $PLUGIN_COMMAND_PREFIX:info lollipop --config-dir
+  #E dokku $PLUGIN_COMMAND_PREFIX:info lollipop --data-dir
+  #E dokku $PLUGIN_COMMAND_PREFIX:info lollipop --dsn
+  #E dokku $PLUGIN_COMMAND_PREFIX:info lollipop --exposed-ports
+  #E dokku $PLUGIN_COMMAND_PREFIX:info lollipop --id
+  #E dokku $PLUGIN_COMMAND_PREFIX:info lollipop --internal-ip
+  #E dokku $PLUGIN_COMMAND_PREFIX:info lollipop --initial-network
+  #E dokku $PLUGIN_COMMAND_PREFIX:info lollipop --links
+  #E dokku $PLUGIN_COMMAND_PREFIX:info lollipop --post-create-network
+  #E dokku $PLUGIN_COMMAND_PREFIX:info lollipop --post-start-network
+  #E dokku $PLUGIN_COMMAND_PREFIX:info lollipop --service-root
+  #E dokku $PLUGIN_COMMAND_PREFIX:info lollipop --status
+  #E dokku $PLUGIN_COMMAND_PREFIX:info lollipop --version
   #A service, service to run command against
   #F --config-dir, show the service configuration directory
   #F --data-dir, show the service data directory
@@ -26,11 +29,14 @@ service-info-cmd() {
   #F --exposed-ports, show service exposed ports
   #F --id, show the service container id
   #F --internal-ip, show the service internal ip
+  #F --initial-network, show the initial network being connected to
   #F --links, show the service app links
+  #F --post-create-network, show the networks to attach to after service container creation
+  #F --post-start-network, show the networks to attach to after service container start
   #F --service-root, show the service root directory
   #F --status, show the service running status
   #F --version, show the service image version
-  declare desc="print the connection information"
+  declare desc="print the service information"
   local cmd="$PLUGIN_COMMAND_PREFIX:info" argv=("$@")
   [[ ${argv[0]} == "$cmd" ]] && shift 1
   declare SERVICE="$1" INFO_FLAG="$2"

subcommands/link

@@ -2,7 +2,7 @@
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/config"
 set -eo pipefail
 [[ $DOKKU_TRACE ]] && set -x
-source "$PLUGIN_BASE_PATH/common/functions"
+source "$PLUGIN_CORE_AVAILABLE_PATH/common/functions"
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/functions"
 
 service-link-cmd() {
@@ -10,38 +10,39 @@ service-link-cmd() {
   #E this will use native docker links via the docker-options plugin.
   #E here we link it to our 'playground' app.
   #E > NOTE: this will restart your app
-  #E dokku $PLUGIN_COMMAND_PREFIX:link lolipop playground
+  #E dokku $PLUGIN_COMMAND_PREFIX:link lollipop playground
   #E the following environment variables will be set automatically by docker
   #E (not on the app itself, so they won’t be listed when calling dokku config):
   #E
-  #E     DOKKU_${PLUGIN_DEFAULT_ALIAS}_LOLIPOP_NAME=/lolipop/DATABASE
-  #E     DOKKU_${PLUGIN_DEFAULT_ALIAS}_LOLIPOP_PORT=tcp://172.17.0.1:${PLUGIN_DATASTORE_PORTS[0]}
-  #E     DOKKU_${PLUGIN_DEFAULT_ALIAS}_LOLIPOP_PORT_${PLUGIN_DATASTORE_PORTS[0]}_TCP=tcp://172.17.0.1:${PLUGIN_DATASTORE_PORTS[0]}
-  #E     DOKKU_${PLUGIN_DEFAULT_ALIAS}_LOLIPOP_PORT_${PLUGIN_DATASTORE_PORTS[0]}_TCP_PROTO=tcp
-  #E     DOKKU_${PLUGIN_DEFAULT_ALIAS}_LOLIPOP_PORT_${PLUGIN_DATASTORE_PORTS[0]}_TCP_PORT=${PLUGIN_DATASTORE_PORTS[0]}
-  #E     DOKKU_${PLUGIN_DEFAULT_ALIAS}_LOLIPOP_PORT_${PLUGIN_DATASTORE_PORTS[0]}_TCP_ADDR=172.17.0.1
+  #E     DOKKU_${PLUGIN_VARIABLE}_LOLLIPOP_NAME=/lollipop/DATABASE
+  #E     DOKKU_${PLUGIN_VARIABLE}_LOLLIPOP_PORT=tcp://172.17.0.1:${PLUGIN_DATASTORE_PORTS[0]}
+  #E     DOKKU_${PLUGIN_VARIABLE}_LOLLIPOP_PORT_${PLUGIN_DATASTORE_PORTS[0]}_TCP=tcp://172.17.0.1:${PLUGIN_DATASTORE_PORTS[0]}
+  #E     DOKKU_${PLUGIN_VARIABLE}_LOLLIPOP_PORT_${PLUGIN_DATASTORE_PORTS[0]}_TCP_PROTO=tcp
+  #E     DOKKU_${PLUGIN_VARIABLE}_LOLLIPOP_PORT_${PLUGIN_DATASTORE_PORTS[0]}_TCP_PORT=${PLUGIN_DATASTORE_PORTS[0]}
+  #E     DOKKU_${PLUGIN_VARIABLE}_LOLLIPOP_PORT_${PLUGIN_DATASTORE_PORTS[0]}_TCP_ADDR=172.17.0.1
   #E
   #E the following will be set on the linked application by default:
   #E
-  #E     ${PLUGIN_DEFAULT_ALIAS}_URL=${PLUGIN_SCHEME}://lolipop:SOME_PASSWORD@dokku-${PLUGIN_COMMAND_PREFIX}-lolipop:${PLUGIN_DATASTORE_PORTS[0]}/lolipop
+  #E     ${PLUGIN_DEFAULT_ALIAS}_URL=${PLUGIN_SCHEME}://lollipop:SOME_PASSWORD@dokku-${PLUGIN_COMMAND_PREFIX}-lollipop:${PLUGIN_DATASTORE_PORTS[0]}/lollipop
   #E
   #E the host exposed here only works internally in docker containers.
   #E if you want your container to be reachable from outside, you should
   #E use the 'expose' subcommand. another service can be linked to your app:
   #E dokku $PLUGIN_COMMAND_PREFIX:link other_service playground
   #E it is possible to change the protocol for ${PLUGIN_DEFAULT_ALIAS}_URL by setting the
-  #E environment variable ${PLUGIN_DEFAULT_ALIAS}_DATABASE_SCHEME on the app. doing so will
+  #E environment variable ${PLUGIN_VARIABLE}_DATABASE_SCHEME on the app. doing so will
   #E after linking will cause the plugin to think the service is not
   #E linked, and we advise you to unlink before proceeding.
-  #E dokku config:set playground ${PLUGIN_DEFAULT_ALIAS}_DATABASE_SCHEME=${PLUGIN_SCHEME}2
-  #E dokku $PLUGIN_COMMAND_PREFIX:link lolipop playground
+  #E dokku config:set playground ${PLUGIN_VARIABLE}_DATABASE_SCHEME=${PLUGIN_SCHEME}2
+  #E dokku $PLUGIN_COMMAND_PREFIX:link lollipop playground
   #E this will cause ${PLUGIN_DEFAULT_ALIAS}_URL to be set as:
   #E
-  #E     ${PLUGIN_SCHEME}2://lolipop:SOME_PASSWORD@dokku-${PLUGIN_COMMAND_PREFIX}-lolipop:${PLUGIN_DATASTORE_PORTS[0]}/lolipop
+  #E     ${PLUGIN_SCHEME}2://lollipop:SOME_PASSWORD@dokku-${PLUGIN_COMMAND_PREFIX}-lollipop:${PLUGIN_DATASTORE_PORTS[0]}/lollipop
   #A service, service to run command against
   #A app, app to run command against
   #F -a|--alias "BLUE_DATABASE", an alternative alias to use for linking to an app via environment variable
   #F -q|--querystring "pool=5", ampersand delimited querystring arguments to append to the service link
+  #F -n|--no-restart "false", whether or not to restart the app on link (default: true)
   declare desc="link the $PLUGIN_SERVICE service to the app"
   local cmd="$PLUGIN_COMMAND_PREFIX:link" argv=("$@")
   [[ ${argv[0]} == "$cmd" ]] && shift 1

subcommands/linked

@@ -2,12 +2,12 @@
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/config"
 set -eo pipefail
 [[ $DOKKU_TRACE ]] && set -x
-source "$PLUGIN_BASE_PATH/common/functions"
+source "$PLUGIN_CORE_AVAILABLE_PATH/common/functions"
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/functions"
 
 service-linked-cmd() {
-  #E here we check if the lolipop $PLUGIN_COMMAND_PREFIX service is linked to the 'playground' app.
-  #E dokku $PLUGIN_COMMAND_PREFIX:linked lolipop playground
+  #E here we check if the lollipop $PLUGIN_COMMAND_PREFIX service is linked to the 'playground' app.
+  #E dokku $PLUGIN_COMMAND_PREFIX:linked lollipop playground
   #A service, service to run command against
   #A app, app to run command against
   declare desc="check if the $PLUGIN_SERVICE service is linked to an app"

subcommands/links

@@ -2,12 +2,12 @@
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/config"
 set -eo pipefail
 [[ $DOKKU_TRACE ]] && set -x
-source "$PLUGIN_BASE_PATH/common/functions"
+source "$PLUGIN_CORE_AVAILABLE_PATH/common/functions"
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/functions"
 
 service-links-cmd() {
-  #E list all apps linked to the 'lolipop' $PLUGIN_COMMAND_PREFIX service.
-  #E dokku $PLUGIN_COMMAND_PREFIX:links lolipop
+  #E list all apps linked to the 'lollipop' $PLUGIN_COMMAND_PREFIX service.
+  #E dokku $PLUGIN_COMMAND_PREFIX:links lollipop
   #A service, service to run command against
   declare desc="list all apps linked to the $PLUGIN_SERVICE service"
   local cmd="$PLUGIN_COMMAND_PREFIX:links" argv=("$@")

subcommands/list

@@ -2,7 +2,7 @@
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/config"
 set -eo pipefail
 [[ $DOKKU_TRACE ]] && set -x
-source "$PLUGIN_BASE_PATH/common/functions"
+source "$PLUGIN_CORE_AVAILABLE_PATH/common/functions"
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/functions"
 
 service-list-cmd() {

subcommands/logs

@@ -2,24 +2,26 @@
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/config"
 set -eo pipefail
 [[ $DOKKU_TRACE ]] && set -x
-source "$PLUGIN_BASE_PATH/common/functions"
+source "$PLUGIN_CORE_AVAILABLE_PATH/common/functions"
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/functions"
 
 service-logs-cmd() {
   #E you can tail logs for a particular service:
-  #E dokku $PLUGIN_COMMAND_PREFIX:logs lolipop
+  #E dokku $PLUGIN_COMMAND_PREFIX:logs lollipop
   #E by default, logs will not be tailed, but you can do this with the --tail flag:
-  #E dokku $PLUGIN_COMMAND_PREFIX:logs lolipop --tail
+  #E dokku $PLUGIN_COMMAND_PREFIX:logs lollipop --tail
+  #E the default tail setting is to show all logs, but an initial count can also be specified
+  #E dokku $PLUGIN_COMMAND_PREFIX:logs lollipop --tail 5
   #A service, service to run command against
-  #F -t|--tail, do not stop when end of the logs are reached and wait for additional output
+  #F -t|--tail [<tail-num>], do not stop when end of the logs are reached and wait for additional output
   declare desc="print the most recent log(s) for this service"
   local cmd="$PLUGIN_COMMAND_PREFIX:logs" argv=("$@")
   [[ ${argv[0]} == "$cmd" ]] && shift 1
-  declare SERVICE="$1" TAIL_FLAG="$2"
+  declare SERVICE="$1" TAIL_FLAG="$2" TAIL_NUM_OPTIONAL="${3:-all}"
 
   [[ -z "$SERVICE" ]] && dokku_log_fail "Please specify a valid name for the service"
   verify_service_name "$SERVICE"
-  service_logs "$SERVICE" "$TAIL_FLAG"
+  service_logs "$SERVICE" "$TAIL_FLAG" "$TAIL_NUM_OPTIONAL"
 }
 
 service-logs-cmd "$@"

subcommands/pause

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

subcommands/promote

@@ -2,7 +2,7 @@
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/config"
 set -eo pipefail
 [[ $DOKKU_TRACE ]] && set -x
-source "$PLUGIN_BASE_PATH/common/functions"
+source "$PLUGIN_CORE_AVAILABLE_PATH/common/functions"
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/functions"
 
 service-promote-cmd() {
@@ -20,7 +20,7 @@ service-promote-cmd() {
   #E
   #E     ${PLUGIN_DEFAULT_ALIAS}_URL=${PLUGIN_SCHEME}://other_service:ANOTHER_PASSWORD@dokku-${PLUGIN_COMMAND_PREFIX}-other-service:${PLUGIN_DATASTORE_PORTS[0]}/other_service
   #E     DOKKU_${PLUGIN_DEFAULT_ALIAS}_BLUE_URL=${PLUGIN_SCHEME}://other_service:ANOTHER_PASSWORD@dokku-${PLUGIN_COMMAND_PREFIX}-other-service:${PLUGIN_DATASTORE_PORTS[0]}/other_service
-  #E     DOKKU_${PLUGIN_DEFAULT_ALIAS}_SILVER_URL=${PLUGIN_SCHEME}://lolipop:SOME_PASSWORD@dokku-${PLUGIN_COMMAND_PREFIX}-lolipop:${PLUGIN_DATASTORE_PORTS[0]}/lolipop
+  #E     DOKKU_${PLUGIN_DEFAULT_ALIAS}_SILVER_URL=${PLUGIN_SCHEME}://lollipop:SOME_PASSWORD@dokku-${PLUGIN_COMMAND_PREFIX}-lollipop:${PLUGIN_DATASTORE_PORTS[0]}/lollipop
   #A service, service to run command against
   #A app, app to run command against
   declare desc="promote service <service> as ${PLUGIN_DEFAULT_ALIAS}_URL in <app>"

subcommands/restart

@@ -2,12 +2,12 @@
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/config"
 set -eo pipefail
 [[ $DOKKU_TRACE ]] && set -x
-source "$PLUGIN_BASE_PATH/common/functions"
+source "$PLUGIN_CORE_AVAILABLE_PATH/common/functions"
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/functions"
 
 service-restart-cmd() {
   #E restart the service
-  #E dokku $PLUGIN_COMMAND_PREFIX:restart lolipop
+  #E dokku $PLUGIN_COMMAND_PREFIX:restart lollipop
   #A service, service to run command against
   declare desc="graceful shutdown and restart of the $PLUGIN_SERVICE service container"
   local cmd="$PLUGIN_COMMAND_PREFIX:restart" argv=("$@")
@@ -16,7 +16,7 @@ service-restart-cmd() {
 
   [[ -z "$SERVICE" ]] && dokku_log_fail "Please specify a valid name for the service"
   verify_service_name "$SERVICE"
-  service_stop "$SERVICE"
+  service_pause "$SERVICE"
   service_start "$SERVICE"
   dokku_log_info1 "Please call dokku ps:restart on all linked apps"
 }

subcommands/set

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

subcommands/start

@@ -2,12 +2,12 @@
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/config"
 set -eo pipefail
 [[ $DOKKU_TRACE ]] && set -x
-source "$PLUGIN_BASE_PATH/common/functions"
+source "$PLUGIN_CORE_AVAILABLE_PATH/common/functions"
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/functions"
 
 service-start-cmd() {
   #E start the service
-  #E dokku $PLUGIN_COMMAND_PREFIX:start lolipop
+  #E dokku $PLUGIN_COMMAND_PREFIX:start lollipop
   #A service, service to run command against
   declare desc="start a previously stopped $PLUGIN_SERVICE service"
   local cmd="$PLUGIN_COMMAND_PREFIX:start" argv=("$@")

subcommands/stop

@@ -2,12 +2,12 @@
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/config"
 set -eo pipefail
 [[ $DOKKU_TRACE ]] && set -x
-source "$PLUGIN_BASE_PATH/common/functions"
+source "$PLUGIN_CORE_AVAILABLE_PATH/common/functions"
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/functions"
 
 service-stop-cmd() {
-  #E stop the service and the running container
-  #E dokku $PLUGIN_COMMAND_PREFIX:stop lolipop
+  #E stop the service and removes the running container
+  #E dokku $PLUGIN_COMMAND_PREFIX:stop lollipop
   #A service, service to run command against
   declare desc="stop a running $PLUGIN_SERVICE service"
   local cmd="$PLUGIN_COMMAND_PREFIX:stop" argv=("$@")
@@ -16,7 +16,7 @@ service-stop-cmd() {
 
   [[ -z "$SERVICE" ]] && dokku_log_fail "Please specify a valid name for the service"
   verify_service_name "$SERVICE"
-  service_stop "$SERVICE"
+  service_container_rm "$SERVICE"
 }
 
 service-stop-cmd "$@"

subcommands/unexpose

@@ -2,12 +2,12 @@
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/config"
 set -eo pipefail
 [[ $DOKKU_TRACE ]] && set -x
-source "$PLUGIN_BASE_PATH/common/functions"
+source "$PLUGIN_CORE_AVAILABLE_PATH/common/functions"
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/functions"
 
 service-unexpose-cmd() {
   #E unexpose the service, removing access to it from the public interface (0.0.0.0)
-  #E dokku $PLUGIN_COMMAND_PREFIX:unexpose lolipop
+  #E dokku $PLUGIN_COMMAND_PREFIX:unexpose lollipop
   #A service, service to run command against
   declare desc="unexpose a previously exposed $PLUGIN_SERVICE service"
   local cmd="$PLUGIN_COMMAND_PREFIX:unexpose" argv=("$@")

subcommands/unlink

@@ -2,15 +2,16 @@
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/config"
 set -eo pipefail
 [[ $DOKKU_TRACE ]] && set -x
-source "$PLUGIN_BASE_PATH/common/functions"
+source "$PLUGIN_CORE_AVAILABLE_PATH/common/functions"
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/functions"
 
 service-unlink-cmd() {
   #E you can unlink a $PLUGIN_COMMAND_PREFIX service
   #E > NOTE: this will restart your app and unset related environment variables
-  #E dokku $PLUGIN_COMMAND_PREFIX:unlink lolipop playground
+  #E dokku $PLUGIN_COMMAND_PREFIX:unlink lollipop playground
   #A service, service to run command against
   #A app, app to run command against
+  #F -n|--no-restart "false", whether or not to restart the app on unlink (default: true)
   declare desc="unlink the $PLUGIN_SERVICE service from the app"
   local cmd="$PLUGIN_COMMAND_PREFIX:unlink" argv=("$@")
   [[ ${argv[0]} == "$cmd" ]] && shift 1

subcommands/upgrade

@@ -2,18 +2,23 @@
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/config"
 set -eo pipefail
 [[ $DOKKU_TRACE ]] && set -x
-source "$PLUGIN_BASE_PATH/common/functions"
+source "$PLUGIN_CORE_AVAILABLE_PATH/common/functions"
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/functions"
 source "$PLUGIN_AVAILABLE_PATH/ps/functions"
 
 service-upgrade-cmd() {
   #E you can upgrade an existing service to a new image or image-version
-  #E dokku $PLUGIN_COMMAND_PREFIX:upgrade lolipop
+  #E dokku $PLUGIN_COMMAND_PREFIX:upgrade lollipop
   #A service, service to run command against
+  #F -c|--config-options "--args --go=here", extra arguments to pass to the container create command
   #F -C|--custom-env "USER=alpha;HOST=beta", semi-colon delimited environment variables to start the service with
   #F -i|--image IMAGE, the image name to start the service with
   #F -I|--image-version IMAGE_VERSION, the image version to start the service with
-  #F -R|--restart-apps "true", whether to force an app restart
+  #F -N|--initial-network INITIAL_NETWORK, the initial network to attach the service to
+  #F -P|--post-create-network NETWORKS, a comma-separated list of networks to attach the service container to after service creation
+  #F -R|--restart-apps "true", whether or not to force an app restart (default: false)
+  #F -S|--post-start-network NETWORKS, a comma-separated list of networks to attach the service container to after service start
+  #F -s|--shm-size SHM_SIZE, override shared memory size for $PLUGIN_COMMAND_PREFIX docker container
   declare desc="upgrade service <service> to the specified versions"
   local cmd="$PLUGIN_COMMAND_PREFIX:upgrade" argv=("$@")
   [[ ${argv[0]} == "$cmd" ]] && shift 1
@@ -26,8 +31,14 @@ service-upgrade-cmd() {
 
   service_parse_args "${@:2}"
 
-  if ! service_image_exists "$SERVICE"; then
-    dokku_log_fail "Unable to proceed with upgrade, image ${PLUGIN_IMAGE}:${PLUGIN_IMAGE_VERSION} does not exist"
+  if ! service_image_exists "$SERVICE" "$PLUGIN_IMAGE" "$PLUGIN_IMAGE_VERSION"; then
+    if [[ "$PLUGIN_DISABLE_PULL" == "true" ]]; then
+      dokku_log_warn "${PLUGIN_DISABLE_PULL_VARIABLE} environment variable detected. Not running pull command." 1>&2
+      dokku_log_warn "   docker image pull ${IMAGE}" 1>&2
+      dokku_log_warn "$PLUGIN_SERVICE service $SERVICE upgrade failed"
+      exit 1
+    fi
+    "$DOCKER_BIN" image pull "$PLUGIN_IMAGE:$PLUGIN_IMAGE_VERSION" || dokku_log_fail "$PLUGIN_SERVICE image $PLUGIN_IMAGE:$PLUGIN_IMAGE_VERSION pull failed"
   fi
 
   local NEW_PLUGIN_IMAGE_TAG="$PLUGIN_IMAGE:$PLUGIN_IMAGE_VERSION"
@@ -36,6 +47,8 @@ service-upgrade-cmd() {
     return
   fi
 
+  service_commit_config "$SERVICE"
+
   dokku_log_info2 "Upgrading $SERVICE to $NEW_PLUGIN_IMAGE_TAG"
   if [[ "$SERVICE_RESTART_APPS" == "true" ]]; then
     dokku_log_info2 "Stopping all linked services"

tests/hook_pre_delete.bats

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

tests/link_networks.bats

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

tests/service_clone.bats

@@ -30,7 +30,7 @@ teardown() {
 @test "($PLUGIN_COMMAND_PREFIX:clone) error when new service already exists" {
   dokku "$PLUGIN_COMMAND_PREFIX:create" new_service
   run dokku "$PLUGIN_COMMAND_PREFIX:clone" l new_service
-  assert_contains "${lines[*]}" "service new_service already exists"
+  assert_contains "${lines[*]}" "Invalid service name new_service"
   assert_failure
 
   dokku --force "$PLUGIN_COMMAND_PREFIX:destroy" new_service

tests/service_export.bats

@@ -20,7 +20,10 @@ teardown() {
 }
 
 @test "($PLUGIN_COMMAND_PREFIX:export) success with SSH_TTY" {
-  export SSH_TTY=`tty`
+  if [[ -n "$GITHUB_WORKFLOW" ]]; then
+    skip "No tty is available on Github Actions"
+  fi
+  export SSH_TTY=$(tty)
   run dokku "$PLUGIN_COMMAND_PREFIX:export" l
   echo "output: $output"
   echo "status: $status"

tests/service_expose.bats

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

tests/service_import.bats

@@ -24,6 +24,9 @@ teardown() {
 }
 
 @test "($PLUGIN_COMMAND_PREFIX:import) error when data is not provided" {
+  if [[ -n "$GITHUB_WORKFLOW" ]]; then
+    skip "No tty is available on Github Actions"
+  fi
   run dokku "$PLUGIN_COMMAND_PREFIX:import" l
   assert_contains "${lines[*]}" "No data provided on stdin"
   assert_failure
@@ -31,7 +34,7 @@ teardown() {
 
 @test "($PLUGIN_COMMAND_PREFIX:import) success" {
   skip "The fake dump is hard to work with in tests"
-  run dokku "$PLUGIN_COMMAND_PREFIX:import" l < "/tmp/fake.dump.tar"
+  run dokku "$PLUGIN_COMMAND_PREFIX:import" l <"/tmp/fake.dump.tar"
   echo "output: $output"
   echo "status: $status"
   assert_success

tests/service_link.bats

@@ -2,18 +2,17 @@
 load test_helper
 
 setup() {
-  dokku "$PLUGIN_COMMAND_PREFIX:create" l
-  dokku "$PLUGIN_COMMAND_PREFIX:create" m
-  dokku apps:create my_app
+  dokku "$PLUGIN_COMMAND_PREFIX:create" ls
+  dokku "$PLUGIN_COMMAND_PREFIX:create" ms
+  dokku apps:create my-app
 }
 
 teardown() {
-  dokku --force "$PLUGIN_COMMAND_PREFIX:destroy" m
-  dokku --force "$PLUGIN_COMMAND_PREFIX:destroy" l
-  dokku --force apps:destroy my_app
+  dokku --force "$PLUGIN_COMMAND_PREFIX:destroy" ms
+  dokku --force "$PLUGIN_COMMAND_PREFIX:destroy" ls
+  dokku --force apps:destroy my-app
 }
 
-
 @test "($PLUGIN_COMMAND_PREFIX:link) error when there are no arguments" {
   run dokku "$PLUGIN_COMMAND_PREFIX:link"
   echo "output: $output"
@@ -23,7 +22,7 @@ teardown() {
 }
 
 @test "($PLUGIN_COMMAND_PREFIX:link) error when the app argument is missing" {
-  run dokku "$PLUGIN_COMMAND_PREFIX:link" l
+  run dokku "$PLUGIN_COMMAND_PREFIX:link" ls
   echo "output: $output"
   echo "status: $status"
   assert_contains "${lines[*]}" "Please specify an app to run the command on"
@@ -31,7 +30,7 @@ teardown() {
 }
 
 @test "($PLUGIN_COMMAND_PREFIX:link) error when the app does not exist" {
-  run dokku "$PLUGIN_COMMAND_PREFIX:link" l not_existing_app
+  run dokku "$PLUGIN_COMMAND_PREFIX:link" ls not_existing_app
   echo "output: $output"
   echo "status: $status"
   assert_contains "${lines[*]}" "App not_existing_app does not exist"
@@ -39,7 +38,7 @@ teardown() {
 }
 
 @test "($PLUGIN_COMMAND_PREFIX:link) error when the service does not exist" {
-  run dokku "$PLUGIN_COMMAND_PREFIX:link" not_existing_service my_app
+  run dokku "$PLUGIN_COMMAND_PREFIX:link" not_existing_service my-app
   echo "output: $output"
   echo "status: $status"
   assert_contains "${lines[*]}" "service not_existing_service does not exist"
@@ -47,73 +46,97 @@ teardown() {
 }
 
 @test "($PLUGIN_COMMAND_PREFIX:link) error when the service is already linked to app" {
-  dokku "$PLUGIN_COMMAND_PREFIX:link" l my_app
-  run dokku "$PLUGIN_COMMAND_PREFIX:link" l my_app
+  dokku "$PLUGIN_COMMAND_PREFIX:link" ls my-app
+  run dokku "$PLUGIN_COMMAND_PREFIX:link" ls my-app
   echo "output: $output"
   echo "status: $status"
   assert_contains "${lines[*]}" "Already linked as MONGO_URL"
   assert_failure
 
-  dokku "$PLUGIN_COMMAND_PREFIX:unlink" l my_app
+  dokku "$PLUGIN_COMMAND_PREFIX:unlink" ls my-app
 }
 
 @test "($PLUGIN_COMMAND_PREFIX:link) exports MONGO_URL to app" {
-  run dokku "$PLUGIN_COMMAND_PREFIX:link" l my_app
+  run dokku "$PLUGIN_COMMAND_PREFIX:link" ls my-app
   echo "output: $output"
   echo "status: $status"
-  url=$(dokku config:get my_app MONGO_URL)
-  password="$(sudo cat "$PLUGIN_DATA_ROOT/l/PASSWORD")"
-  assert_contains "$url" "mongodb://l:$password@dokku-mongo-l:27017/l"
+  url=$(dokku config:get my-app MONGO_URL)
+  password="$(sudo cat "$PLUGIN_DATA_ROOT/ls/PASSWORD")"
+  assert_contains "$url" "mongodb://ls:$password@dokku-mongo-ls:27017/ls"
   assert_success
-  dokku "$PLUGIN_COMMAND_PREFIX:unlink" l my_app
+  dokku "$PLUGIN_COMMAND_PREFIX:unlink" ls my-app
 }
 
 @test "($PLUGIN_COMMAND_PREFIX:link) generates an alternate config url when MONGO_URL already in use" {
-  dokku config:set my_app MONGO_URL=mongodb://user:pass@host:27017/db
-  dokku "$PLUGIN_COMMAND_PREFIX:link" l my_app
-  run dokku config my_app
+  dokku config:set my-app MONGO_URL=mongodb://user:pass@host:27017/db
+  dokku "$PLUGIN_COMMAND_PREFIX:link" ls my-app
+  run dokku config my-app
   assert_contains "${lines[*]}" "DOKKU_MONGO_AQUA_URL"
   assert_success
 
-  dokku "$PLUGIN_COMMAND_PREFIX:link" m my_app
-  run dokku config my_app
+  dokku "$PLUGIN_COMMAND_PREFIX:link" ms my-app
+  run dokku config my-app
   assert_contains "${lines[*]}" "DOKKU_MONGO_BLACK_URL"
   assert_success
-  dokku "$PLUGIN_COMMAND_PREFIX:unlink" m my_app
-  dokku "$PLUGIN_COMMAND_PREFIX:unlink" l my_app
+  dokku "$PLUGIN_COMMAND_PREFIX:unlink" ms my-app
+  dokku "$PLUGIN_COMMAND_PREFIX:unlink" ls my-app
 }
 
 @test "($PLUGIN_COMMAND_PREFIX:link) links to app with docker-options" {
-  dokku "$PLUGIN_COMMAND_PREFIX:link" l my_app
-  run dokku docker-options my_app
-  assert_contains "${lines[*]}" "--link dokku.mongo.l:dokku-mongo-l"
+  dokku "$PLUGIN_COMMAND_PREFIX:link" ls my-app
+  run dokku docker-options:report my-app
+  assert_contains "${lines[*]}" "--link dokku.mongo.ls:dokku-mongo-ls"
   assert_success
-  dokku "$PLUGIN_COMMAND_PREFIX:unlink" l my_app
+  dokku "$PLUGIN_COMMAND_PREFIX:unlink" ls my-app
 }
 
 @test "($PLUGIN_COMMAND_PREFIX:link) uses apps MONGO_DATABASE_SCHEME variable" {
-  dokku config:set my_app MONGO_DATABASE_SCHEME=mongodb2
-  dokku "$PLUGIN_COMMAND_PREFIX:link" l my_app
-  url=$(dokku config:get my_app MONGO_URL)
-  password="$(sudo cat "$PLUGIN_DATA_ROOT/l/PASSWORD")"
-  assert_contains "$url" "mongodb2://l:$password@dokku-mongo-l:27017/l"
+  dokku config:set my-app MONGO_DATABASE_SCHEME=mongodb2
+  dokku "$PLUGIN_COMMAND_PREFIX:link" ls my-app
+  url=$(dokku config:get my-app MONGO_URL)
+  password="$(sudo cat "$PLUGIN_DATA_ROOT/ls/PASSWORD")"
+  assert_contains "$url" "mongodb2://ls:$password@dokku-mongo-ls:27017/ls"
   assert_success
-  dokku "$PLUGIN_COMMAND_PREFIX:unlink" l my_app
+  dokku "$PLUGIN_COMMAND_PREFIX:unlink" ls my-app
 }
 
 @test "($PLUGIN_COMMAND_PREFIX:link) adds a querystring" {
-  dokku "$PLUGIN_COMMAND_PREFIX:link" l my_app --querystring "pool=5"
-  url=$(dokku config:get my_app MONGO_URL)
+  dokku "$PLUGIN_COMMAND_PREFIX:link" ls my-app --querystring "pool=5"
+  url=$(dokku config:get my-app MONGO_URL)
   assert_contains "$url" "?pool=5"
   assert_success
-  dokku "$PLUGIN_COMMAND_PREFIX:unlink" l my_app
+  dokku "$PLUGIN_COMMAND_PREFIX:unlink" ls my-app
 }
 
 @test "($PLUGIN_COMMAND_PREFIX:link) uses a specified config url when alias is specified" {
-  dokku "$PLUGIN_COMMAND_PREFIX:link" l my_app --alias "ALIAS"
-  url=$(dokku config:get my_app ALIAS_URL)
-  password="$(sudo cat "$PLUGIN_DATA_ROOT/l/PASSWORD")"
-  assert_contains "$url" "mongodb://l:$password@dokku-mongo-l:27017/l"
+  dokku "$PLUGIN_COMMAND_PREFIX:link" ls my-app --alias "ALIAS"
+  url=$(dokku config:get my-app ALIAS_URL)
+  password="$(sudo cat "$PLUGIN_DATA_ROOT/ls/PASSWORD")"
+  assert_contains "$url" "mongodb://ls:$password@dokku-mongo-ls:27017/ls"
+  assert_success
+  dokku "$PLUGIN_COMMAND_PREFIX:unlink" ls my-app
+}
+
+@test "($PLUGIN_COMMAND_PREFIX:link) respects --no-restart" {
+  run dokku "$PLUGIN_COMMAND_PREFIX:link" ls my-app
+  echo "output: $output"
+  echo "status: $status"
+  assert_output_contains "Skipping restart of linked app" 0
+  assert_success
+
+  run dokku "$PLUGIN_COMMAND_PREFIX:unlink" ls my-app
+  echo "output: $output"
+  echo "status: $status"
+  assert_success
+
+  run dokku "$PLUGIN_COMMAND_PREFIX:link" ls my-app --no-restart
+  echo "output: $output"
+  echo "status: $status"
+  assert_output_contains "Skipping restart of linked app"
+  assert_success
+
+  run dokku "$PLUGIN_COMMAND_PREFIX:unlink" ls my-app
+  echo "output: $output"
+  echo "status: $status"
   assert_success
-  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"
-  assert_contains "${lines[*]}" "l     mongo:3.6.15  running  -              -"
-}
-
-@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
+  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 MongoDB services"
+  assert_output "${lines[*]}" "There are no $PLUGIN_SERVICE services"
   dokku "$PLUGIN_COMMAND_PREFIX:create" l
 }

tests/service_pause.bats

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

tests/service_promote.bats

@@ -3,14 +3,14 @@ load test_helper
 
 setup() {
   dokku "$PLUGIN_COMMAND_PREFIX:create" l
-  dokku apps:create my_app
-  dokku "$PLUGIN_COMMAND_PREFIX:link" l my_app
+  dokku apps:create my-app
+  dokku "$PLUGIN_COMMAND_PREFIX:link" l my-app
 }
 
 teardown() {
-  dokku "$PLUGIN_COMMAND_PREFIX:unlink" l my_app
+  dokku "$PLUGIN_COMMAND_PREFIX:unlink" l my-app
   dokku --force "$PLUGIN_COMMAND_PREFIX:destroy" l
-  dokku --force apps:destroy my_app
+  dokku --force apps:destroy my-app
 }
 
 @test "($PLUGIN_COMMAND_PREFIX:promote) error when there are no arguments" {
@@ -29,34 +29,34 @@ teardown() {
 }
 
 @test "($PLUGIN_COMMAND_PREFIX:promote) error when the service does not exist" {
-  run dokku "$PLUGIN_COMMAND_PREFIX:promote" not_existing_service my_app
+  run dokku "$PLUGIN_COMMAND_PREFIX:promote" not_existing_service my-app
   assert_contains "${lines[*]}" "service not_existing_service does not exist"
 }
 
 @test "($PLUGIN_COMMAND_PREFIX:promote) error when the service is already promoted" {
-  run dokku "$PLUGIN_COMMAND_PREFIX:promote" l my_app
+  run dokku "$PLUGIN_COMMAND_PREFIX:promote" l my-app
   assert_contains "${lines[*]}" "already promoted as MONGO_URL"
 }
 
 @test "($PLUGIN_COMMAND_PREFIX:promote) changes MONGO_URL" {
   password="$(sudo cat "$PLUGIN_DATA_ROOT/l/PASSWORD")"
-  dokku config:set my_app "MONGO_URL=mongodb://u:p@host:27017/db" "DOKKU_MONGO_BLUE_URL=mongodb://l:$password@dokku-mongo-l:27017/l"
-  dokku "$PLUGIN_COMMAND_PREFIX:promote" l my_app
-  url=$(dokku config:get my_app MONGO_URL)
+  dokku config:set my-app "MONGO_URL=mongodb://u:p@host:27017/db" "DOKKU_MONGO_BLUE_URL=mongodb://l:$password@dokku-mongo-l:27017/l"
+  dokku "$PLUGIN_COMMAND_PREFIX:promote" l my-app
+  url=$(dokku config:get my-app MONGO_URL)
   assert_equal "$url" "mongodb://l:$password@dokku-mongo-l:27017/l"
 }
 
 @test "($PLUGIN_COMMAND_PREFIX:promote) creates new config url when needed" {
   password="$(sudo cat "$PLUGIN_DATA_ROOT/l/PASSWORD")"
-  dokku config:set my_app "MONGO_URL=mongodb://u:p@host:27017/db" "DOKKU_MONGO_BLUE_URL=mongodb://l:$password@dokku-mongo-l:27017/l"
-  dokku "$PLUGIN_COMMAND_PREFIX:promote" l my_app
-  run dokku config my_app
+  dokku config:set my-app "MONGO_URL=mongodb://u:p@host:27017/db" "DOKKU_MONGO_BLUE_URL=mongodb://l:$password@dokku-mongo-l:27017/l"
+  dokku "$PLUGIN_COMMAND_PREFIX:promote" l my-app
+  run dokku config my-app
   assert_contains "${lines[*]}" "DOKKU_MONGO_"
 }
 @test "($PLUGIN_COMMAND_PREFIX:promote) uses MONGO_DATABASE_SCHEME variable" {
   password="$(sudo cat "$PLUGIN_DATA_ROOT/l/PASSWORD")"
-  dokku config:set my_app "MONGO_DATABASE_SCHEME=mongodb2" "MONGO_URL=mongodb://u:p@host:27017/db" "DOKKU_MONGO_BLUE_URL=mongodb2://l:$password@dokku-mongo-l:27017/l"
-  dokku "$PLUGIN_COMMAND_PREFIX:promote" l my_app
-  url=$(dokku config:get my_app MONGO_URL)
+  dokku config:set my-app "MONGO_DATABASE_SCHEME=mongodb2" "MONGO_URL=mongodb://u:p@host:27017/db" "DOKKU_MONGO_BLUE_URL=mongodb2://l:$password@dokku-mongo-l:27017/l"
+  dokku "$PLUGIN_COMMAND_PREFIX:promote" l my-app
+  url=$(dokku config:get my-app MONGO_URL)
   assert_contains "$url" "mongodb2://l:$password@dokku-mongo-l:27017/l"
 }

tests/service_restart.bats

@@ -23,4 +23,3 @@ teardown() {
   run dokku "$PLUGIN_COMMAND_PREFIX:restart" l
   assert_success
 }
-

tests/service_start.bats

@@ -23,4 +23,3 @@ teardown() {
   run dokku "$PLUGIN_COMMAND_PREFIX:start" l
   assert_success
 }
-

tests/service_stop.bats

@@ -23,4 +23,3 @@ teardown() {
   run dokku "$PLUGIN_COMMAND_PREFIX:stop" l
   assert_success
 }
-

tests/service_unexpose.bats

@@ -25,4 +25,3 @@ teardown() {
   [[ ! -f $PLUGIN_DATA_ROOT/PORT ]]
   assert_contains "${lines[*]}" "Service l unexposed"
 }
-

tests/service_unlink.bats

@@ -2,13 +2,13 @@
 load test_helper
 
 setup() {
-  dokku apps:create my_app
-  dokku "$PLUGIN_COMMAND_PREFIX:create" l
+  dokku apps:create my-app
+  dokku "$PLUGIN_COMMAND_PREFIX:create" ls
 }
 
 teardown() {
-  dokku --force "$PLUGIN_COMMAND_PREFIX:destroy" l
-  dokku --force apps:destroy my_app
+  dokku --force "$PLUGIN_COMMAND_PREFIX:destroy" ls
+  dokku --force apps:destroy my-app
 }
 
 @test "($PLUGIN_COMMAND_PREFIX:unlink) error when there are no arguments" {
@@ -17,37 +17,61 @@ teardown() {
 }
 
 @test "($PLUGIN_COMMAND_PREFIX:unlink) error when the app argument is missing" {
-  run dokku "$PLUGIN_COMMAND_PREFIX:unlink" l
+  run dokku "$PLUGIN_COMMAND_PREFIX:unlink" ls
   assert_contains "${lines[*]}" "Please specify an app to run the command on"
 }
 
 @test "($PLUGIN_COMMAND_PREFIX:unlink) error when the app does not exist" {
-  run dokku "$PLUGIN_COMMAND_PREFIX:unlink" l not_existing_app
+  run dokku "$PLUGIN_COMMAND_PREFIX:unlink" ls not_existing_app
   assert_contains "${lines[*]}" "App not_existing_app does not exist"
 }
 
 @test "($PLUGIN_COMMAND_PREFIX:unlink) error when the service does not exist" {
-  run dokku "$PLUGIN_COMMAND_PREFIX:unlink" not_existing_service my_app
+  run dokku "$PLUGIN_COMMAND_PREFIX:unlink" not_existing_service my-app
   assert_contains "${lines[*]}" "service not_existing_service does not exist"
 }
 
 @test "($PLUGIN_COMMAND_PREFIX:unlink) error when service not linked to app" {
-  run dokku "$PLUGIN_COMMAND_PREFIX:unlink" l my_app
-  assert_contains "${lines[*]}" "Not linked to app my_app"
+  run dokku "$PLUGIN_COMMAND_PREFIX:unlink" ls my-app
+  assert_contains "${lines[*]}" "Not linked to app my-app"
 }
 
 @test "($PLUGIN_COMMAND_PREFIX:unlink) removes link from docker-options" {
-  dokku "$PLUGIN_COMMAND_PREFIX:link" l my_app >&2
-  dokku "$PLUGIN_COMMAND_PREFIX:unlink" l my_app
+  dokku "$PLUGIN_COMMAND_PREFIX:link" ls my-app >&2
+  dokku "$PLUGIN_COMMAND_PREFIX:unlink" ls my-app
 
   check_value="Docker options build: Docker options deploy: --restart=on-failure:10 Docker options run:"
-  options=$(dokku --quiet docker-options:report my_app | xargs)
+  options=$(dokku --quiet docker-options:report my-app | xargs)
   assert_equal "$options" "$check_value"
 }
 
 @test "($PLUGIN_COMMAND_PREFIX:unlink) unsets config url from app" {
-  dokku "$PLUGIN_COMMAND_PREFIX:link" l my_app >&2
-  dokku "$PLUGIN_COMMAND_PREFIX:unlink" l my_app
-  config=$(dokku config:get my_app MONGO_URL || true)
+  dokku "$PLUGIN_COMMAND_PREFIX:link" ls my-app >&2
+  dokku "$PLUGIN_COMMAND_PREFIX:unlink" ls my-app
+  config=$(dokku config:get my-app MONGO_URL || true)
   assert_equal "$config" ""
 }
+
+@test "($PLUGIN_COMMAND_PREFIX:unlink) respects --no-restart" {
+  run dokku "$PLUGIN_COMMAND_PREFIX:link" ls my-app
+  echo "output: $output"
+  echo "status: $status"
+  assert_success
+
+  run dokku "$PLUGIN_COMMAND_PREFIX:unlink" ls my-app
+  echo "output: $output"
+  echo "status: $status"
+  assert_output_contains "Skipping restart of linked app" 0
+  assert_success
+
+  run dokku "$PLUGIN_COMMAND_PREFIX:link" ls my-app
+  echo "output: $output"
+  echo "status: $status"
+  assert_success
+
+  run dokku "$PLUGIN_COMMAND_PREFIX:unlink" ls my-app --no-restart
+  echo "output: $output"
+  echo "status: $status"
+  assert_output_contains "Skipping restart of linked app"
+  assert_success
+}

tests/setup.sh

@@ -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
@@ -15,12 +19,15 @@ echo "Dokku version $DOKKU_VERSION"
 
 export DOKKU_LIB_ROOT="/var/lib/dokku"
 export DOKKU_PLUGINS_ROOT="$DOKKU_LIB_ROOT/plugins/available"
-source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/config"
+pushd "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")" >/dev/null
+source "config"
+popd >/dev/null
 sudo rm -rf "$DOKKU_PLUGINS_ROOT/$PLUGIN_COMMAND_PREFIX"
-sudo mkdir -p "$DOKKU_PLUGINS_ROOT/$PLUGIN_COMMAND_PREFIX" "$DOKKU_PLUGINS_ROOT/$PLUGIN_COMMAND_PREFIX/subcommands" "$DOKKU_PLUGINS_ROOT/$PLUGIN_COMMAND_PREFIX/scripts"
+sudo mkdir -p "$DOKKU_PLUGINS_ROOT/$PLUGIN_COMMAND_PREFIX" "$DOKKU_PLUGINS_ROOT/$PLUGIN_COMMAND_PREFIX/subcommands" "$DOKKU_PLUGINS_ROOT/$PLUGIN_COMMAND_PREFIX/scripts" "$DOKKU_PLUGINS_ROOT/$PLUGIN_COMMAND_PREFIX/templates"
 sudo find ./ -maxdepth 1 -type f -exec cp '{}' "$DOKKU_PLUGINS_ROOT/$PLUGIN_COMMAND_PREFIX" \;
 [[ -d "./scripts" ]] && sudo find ./scripts -maxdepth 1 -type f -exec cp '{}' "$DOKKU_PLUGINS_ROOT/$PLUGIN_COMMAND_PREFIX/scripts" \;
 [[ -d "./subcommands" ]] && sudo find ./subcommands -maxdepth 1 -type f -exec cp '{}' "$DOKKU_PLUGINS_ROOT/$PLUGIN_COMMAND_PREFIX/subcommands" \;
+[[ -d "./templates" ]] && sudo find ./templates -maxdepth 1 -type f -exec cp '{}' "$DOKKU_PLUGINS_ROOT/$PLUGIN_COMMAND_PREFIX/templates" \;
 sudo mkdir -p "$PLUGIN_CONFIG_ROOT" "$PLUGIN_DATA_ROOT"
 sudo dokku plugin:enable "$PLUGIN_COMMAND_PREFIX"
 sudo dokku plugin:install

tests/shellcheck-exclude

@@ -1,3 +1,8 @@
 # SC1090 - Can't follow non-constant source. Use a directive to specify location - https://github.com/koalaman/shellcheck/wiki/SC1090
+# SC1091 - Not following - <https://github.com/koalaman/shellcheck/wiki/SC1091>
 # SC2034 - Variable appears unused. Verify it or export it - https://github.com/koalaman/shellcheck/wiki/SC2034
 # SC2155 - Declare and assign separately to avoid masking return values - https://github.com/koalaman/shellcheck/wiki/SC2155
+# SC2206 - Quote to prevent word splitting/globbing, or split robustly with mapfile or read -a - https://github.com/koalaman/shellcheck/wiki/SC2206
+# SC2207 - Prefer mapfile or read -a to split command output (or quote to avoid splitting) - https://github.com/koalaman/shellcheck/wiki/SC2207
+# SC2220 - Invalid flags are not handled. Add a *) case - https://github.com/koalaman/shellcheck/wiki/SC2220
+# SC2230 - which is non-standard. Use builtin 'command -v' instead - https://github.com/koalaman/shellcheck/wiki/SC2230

tests/shellcheck-to-junit

@@ -1,4 +1,4 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3
 # -*- coding: utf-8 -*-
 from __future__ import print_function
 import argparse

tests/test_helper.bash

@@ -70,3 +70,17 @@ assert_output() {
   fi
   assert_equal "$expected" "$output"
 }
+
+# ShellCheck doesn't know about $output from Bats
+# shellcheck disable=SC2154
+assert_output_contains() {
+  local input="$output"
+  local expected="$1"
+  local count="${2:-1}"
+  local found=0
+  until [ "${input/$expected/}" = "$input" ]; do
+    input="${input/$expected/}"
+    found=$((found + 1))
+  done
+  assert_equal "$count" "$found"
+}