623d125e83
This pull request switches testing to use an actual docker daemon, vs mocking everything out. It may also catch actual breaking issues in our tests, which is great!
746 lines
25 KiB
Bash
Executable File
746 lines
25 KiB
Bash
Executable File
#!/usr/bin/env bash
|
|
set -eo pipefail; [[ $DOKKU_TRACE ]] && set -x
|
|
source "$PLUGIN_AVAILABLE_PATH/config/functions"
|
|
|
|
docker_ports_options() {
|
|
declare desc="Exports 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]} "
|
|
done
|
|
}
|
|
|
|
get_container_ip() {
|
|
declare desc="Retrieves the ip address of a container"
|
|
declare CONTAINER_ID="$1"
|
|
docker inspect --format '{{ .NetworkSettings.IPAddress }}' "$CONTAINER_ID"
|
|
}
|
|
|
|
get_database_name() {
|
|
declare desc="Retrieves a sanitized database name"
|
|
declare DATABASE="$1"
|
|
# some datastores do not like special characters in database names
|
|
# so we need to normalize them out
|
|
echo "$DATABASE" | tr .- _
|
|
}
|
|
|
|
get_random_ports() {
|
|
declare desc="Retrieves N random ports"
|
|
declare iterations="${1:-1}"
|
|
for (( i=0; i < iterations; i++ )); do
|
|
local port=$RANDOM
|
|
local quit=0
|
|
while [ "$quit" -ne 1 ]; do
|
|
netstat -an | grep $port > /dev/null
|
|
# shellcheck disable=SC2181
|
|
if [ $? -gt 0 ]; then
|
|
quit=1
|
|
else
|
|
port=$((port + 1))
|
|
fi
|
|
done
|
|
echo $port
|
|
done
|
|
}
|
|
|
|
get_service_name() {
|
|
declare desc="Retrieves 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 EXISTING_CONFIG="$1" CONFIG_VAR="$2"
|
|
echo "$EXISTING_CONFIG" | grep "$CONFIG_VAR" | sed "s/$CONFIG_VAR:\s*//" | xargs
|
|
}
|
|
|
|
is_container_status() {
|
|
declare desc="Returns 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)
|
|
|
|
if [[ "$CONTAINER_STATUS" == "true" ]]; then
|
|
return 0
|
|
fi
|
|
return 1
|
|
}
|
|
|
|
is_implemented_command() {
|
|
declare desc="return true if value ($1) is in list (all other arguments)"
|
|
declare CMD="$1"
|
|
CMD="$(echo "$CMD" | cut -d ':' -f2)"
|
|
|
|
if [[ ${#PLUGIN_UNIMPLEMENTED_SUBCOMMANDS[@]} -eq 0 ]]; then
|
|
return 0
|
|
fi
|
|
|
|
local e
|
|
for e in "${PLUGIN_UNIMPLEMENTED_SUBCOMMANDS[@]}"; do
|
|
[[ "$e" == "$CMD" ]] && return 1
|
|
done
|
|
return 0
|
|
}
|
|
|
|
remove_from_links_file() {
|
|
declare desc="Removes 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"
|
|
|
|
if [[ ! -f "$LINKS_FILE" ]]; then
|
|
return
|
|
fi
|
|
|
|
sed -i.bak "/^$APP\$/d" "$LINKS_FILE" && rm "$LINKS_FILE.bak"
|
|
sort "$LINKS_FILE" -u -o "$LINKS_FILE"
|
|
}
|
|
|
|
service_dns_hostname() {
|
|
declare desc="Retrieves the alias of a service"
|
|
declare SERVICE="$1"
|
|
local SERVICE_NAME="$(get_service_name "$SERVICE")"
|
|
echo "$SERVICE_NAME" | tr ._ -
|
|
}
|
|
|
|
service_alternative_alias() {
|
|
declare desc="Retrieves 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;
|
|
|
|
for COLOR in "${COLORS[@]}"; do
|
|
ALIAS="${PLUGIN_ALT_ALIAS}_${COLOR}"
|
|
local IN_USE=$(echo "$EXISTING_CONFIG" | grep "${ALIAS}_URL")
|
|
if [[ -n $IN_USE ]]; then
|
|
unset ALIAS
|
|
fi
|
|
done
|
|
echo "$ALIAS"
|
|
}
|
|
|
|
service_app_links() {
|
|
declare desc="Outputs all service links for a given app"
|
|
declare APP="$1"
|
|
local SERVICE LINKED_APP
|
|
|
|
pushd "$PLUGIN_DATA_ROOT" > /dev/null
|
|
for SERVICE in *; do
|
|
[[ -f "$SERVICE/LINKS" ]] || continue
|
|
for LINKED_APP in $(<"$SERVICE/LINKS"); do
|
|
if [[ "$LINKED_APP" == "$APP" ]] ; then
|
|
echo "$SERVICE"
|
|
fi
|
|
done
|
|
done
|
|
}
|
|
|
|
service_backup() {
|
|
declare desc="Creates 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"
|
|
local AWS_ACCESS_KEY_ID_FILE="$SERVICE_BACKUP_ROOT/AWS_ACCESS_KEY_ID"
|
|
local AWS_SECRET_ACCESS_KEY_FILE="$SERVICE_BACKUP_ROOT/AWS_SECRET_ACCESS_KEY"
|
|
local SERVICE_ROOT="$PLUGIN_DATA_ROOT/$SERVICE"
|
|
local ID="$(cat "$SERVICE_ROOT/ID")"
|
|
local BACKUP_PARAMETERS=""
|
|
|
|
if [[ -z "$USE_IAM_OPTIONAL_FLAG" ]]; then
|
|
[[ ! -f "$AWS_ACCESS_KEY_ID_FILE" ]] && dokku_log_fail "Missing AWS_ACCESS_KEY_ID file"
|
|
[[ ! -f "$AWS_SECRET_ACCESS_KEY_FILE" ]] && dokku_log_fail "Missing AWS_SECRET_ACCESS_KEY file"
|
|
BACKUP_PARAMETERS="$BACKUP_PARAMETERS -e AWS_ACCESS_KEY_ID=$(cat "$AWS_ACCESS_KEY_ID_FILE") -e AWS_SECRET_ACCESS_KEY=$(cat "$AWS_SECRET_ACCESS_KEY_FILE")"
|
|
elif [[ "$USE_IAM_OPTIONAL_FLAG" != "--use-iam" ]] && [[ "$USE_IAM_OPTIONAL_FLAG" != "-u" ]]; then
|
|
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
|
|
|
|
docker inspect "$ID" &> /dev/null || dokku_log_fail "Service container does not exist"
|
|
is_container_status "$ID" "Running" || dokku_log_fail "Service container is not running"
|
|
|
|
(service_export "$SERVICE" > "${TMPDIR}/export")
|
|
|
|
# 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"
|
|
|
|
if [[ -f "$SERVICE_BACKUP_ROOT/AWS_DEFAULT_REGION" ]]; then
|
|
BACKUP_PARAMETERS="$BACKUP_PARAMETERS -e AWS_DEFAULT_REGION=$(cat "$SERVICE_BACKUP_ROOT/AWS_DEFAULT_REGION")"
|
|
fi
|
|
|
|
if [[ -f "$SERVICE_BACKUP_ROOT/AWS_SIGNATURE_VERSION" ]]; then
|
|
BACKUP_PARAMETERS="$BACKUP_PARAMETERS -e AWS_SIGNATURE_VERSION=$(cat "$SERVICE_BACKUP_ROOT/AWS_SIGNATURE_VERSION")"
|
|
fi
|
|
|
|
if [[ -f "$SERVICE_BACKUP_ROOT/ENDPOINT_URL" ]]; then
|
|
BACKUP_PARAMETERS="$BACKUP_PARAMETERS -e ENDPOINT_URL=$(cat "$SERVICE_BACKUP_ROOT/ENDPOINT_URL")"
|
|
fi
|
|
|
|
if [[ -f "$BACKUP_ENCRYPTION_CONFIG_ROOT/ENCRYPTION_KEY" ]]; then
|
|
BACKUP_PARAMETERS="$BACKUP_PARAMETERS -e ENCRYPTION_KEY=$(cat "$BACKUP_ENCRYPTION_CONFIG_ROOT/ENCRYPTION_KEY")"
|
|
fi
|
|
|
|
# shellcheck disable=SC2086
|
|
docker run --rm $BACKUP_PARAMETERS dokkupaas/s3backup:0.8.0
|
|
}
|
|
|
|
service_backup_auth() {
|
|
declare desc="Sets 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"
|
|
|
|
mkdir "$SERVICE_BACKUP_ROOT"
|
|
echo "$AWS_ACCESS_KEY_ID" > "$SERVICE_BACKUP_ROOT/AWS_ACCESS_KEY_ID"
|
|
echo "$AWS_SECRET_ACCESS_KEY" > "$SERVICE_BACKUP_ROOT/AWS_SECRET_ACCESS_KEY"
|
|
|
|
if [[ -n "$AWS_DEFAULT_REGION" ]]; then
|
|
echo "$AWS_DEFAULT_REGION" > "$SERVICE_BACKUP_ROOT/AWS_DEFAULT_REGION"
|
|
fi
|
|
|
|
if [[ -n "$AWS_SIGNATURE_VERSION" ]]; then
|
|
echo "$AWS_SIGNATURE_VERSION" > "$SERVICE_BACKUP_ROOT/AWS_SIGNATURE_VERSION"
|
|
fi
|
|
|
|
if [[ -n "$ENDPOINT_URL" ]]; then
|
|
echo "$ENDPOINT_URL" > "$SERVICE_BACKUP_ROOT/ENDPOINT_URL"
|
|
fi
|
|
}
|
|
|
|
service_backup_deauth() {
|
|
declare desc="Removes authentication"
|
|
declare SERVICE="$1"
|
|
local SERVICE_ROOT="${PLUGIN_DATA_ROOT}/${SERVICE}"
|
|
local SERVICE_BACKUP_ROOT="${SERVICE_ROOT}/backup/"
|
|
|
|
rm -rf "$SERVICE_BACKUP_ROOT"
|
|
}
|
|
|
|
service_backup_schedule() {
|
|
declare desc="schedules a backup of the service"
|
|
declare SERVICE="$1" SCHEDULE="$2" BUCKET_NAME="$3" USE_IAM_OPTIONAL_FLAG="$4"
|
|
local DOKKU_BIN="$(which dokku)"
|
|
local CRON_FILE="/etc/cron.d/dokku-${PLUGIN_COMMAND_PREFIX}-${SERVICE}"
|
|
local TMP_CRON_FILE="${PLUGIN_DATA_ROOT}/.TMP_CRON_FILE"
|
|
|
|
if [[ -n "$USE_IAM_OPTIONAL_FLAG" ]] && [[ "$USE_IAM_OPTIONAL_FLAG" != "--use-iam" ]] && [[ "$USE_IAM_OPTIONAL_FLAG" != "-u" ]]; then
|
|
dokku_log_fail "Invalid flag provided, only '--use-iam' allowed"
|
|
fi
|
|
|
|
echo "${SCHEDULE} dokku ${DOKKU_BIN} ${PLUGIN_COMMAND_PREFIX}:backup ${SERVICE} ${BUCKET_NAME} ${USE_IAM_OPTIONAL_FLAG}" > "$TMP_CRON_FILE"
|
|
sudo /bin/mv "$TMP_CRON_FILE" "$CRON_FILE"
|
|
sudo /bin/chown root:root "$CRON_FILE"
|
|
sudo /bin/chmod 644 "$CRON_FILE"
|
|
}
|
|
|
|
service_backup_schedule_cat() {
|
|
declare desc="cat the contents of the configured backup cronfile for the service"
|
|
declare SERVICE="$1"
|
|
local CRON_FILE="/etc/cron.d/dokku-${PLUGIN_COMMAND_PREFIX}-${SERVICE}"
|
|
|
|
if [[ ! -f "$CRON_FILE" ]]; then
|
|
dokku_log_fail "There is no scheduled backup for ${SERVICE}."
|
|
fi
|
|
|
|
cat "$CRON_FILE"
|
|
}
|
|
|
|
service_backup_unschedule() {
|
|
declare desc="unschedules the backup of the service"
|
|
declare SERVICE="$1"
|
|
local CRON_FILE="/etc/cron.d/dokku-${PLUGIN_COMMAND_PREFIX}-${SERVICE}"
|
|
|
|
sudo /bin/rm -f "$CRON_FILE"
|
|
}
|
|
|
|
service_backup_set_encryption() {
|
|
declare desc="Sets 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/"
|
|
|
|
mkdir "$SERVICE_BACKUP_ENCRYPTION_ROOT"
|
|
echo "$ENCRYPTION_KEY" > "${SERVICE_BACKUP_ENCRYPTION_ROOT}/ENCRYPTION_KEY"
|
|
}
|
|
|
|
service_backup_unset_encryption() {
|
|
declare desc="Removes 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_container_rm() {
|
|
declare desc="Stops a service and removes 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
|
|
# 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
|
|
dokku_log_fail "Unable to remove container for service $SERVICE"
|
|
fi
|
|
}
|
|
|
|
service_enter() {
|
|
declare desc="enters 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"
|
|
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}"
|
|
}
|
|
|
|
service_exposed_ports() {
|
|
declare desc="Lists exposed ports for a service"
|
|
declare SERVICE="$1"
|
|
local SERVICE_ROOT="$PLUGIN_DATA_ROOT/$SERVICE"
|
|
local PORT_FILE="$SERVICE_ROOT/PORT"
|
|
[[ ! -f $PORT_FILE ]] && echo '-' && return 0
|
|
local PORTS=($(cat "$PORT_FILE"))
|
|
for (( i=0; i < ${#PLUGIN_DATASTORE_PORTS[@]}; i++ )); do
|
|
echo -n "${PLUGIN_DATASTORE_PORTS[i]}->${PORTS[i]} "
|
|
done
|
|
}
|
|
|
|
service_image_exists() {
|
|
declare desc="Checks if the current image exists"
|
|
local IMAGE="$PLUGIN_IMAGE:$PLUGIN_IMAGE_VERSION"
|
|
|
|
if [[ "$(docker images -q "$IMAGE" 2> /dev/null)" == "" ]]; then
|
|
return 1
|
|
fi
|
|
|
|
return 0
|
|
}
|
|
|
|
service_info() {
|
|
declare desc="Retrieves information about a given service"
|
|
declare SERVICE="$1" INFO_FLAG="$2"
|
|
local SERVICE_ROOT="$PLUGIN_DATA_ROOT/$SERVICE"
|
|
local SERVICE_URL=$(service_url "$SERVICE")
|
|
local PORT_FILE="$SERVICE_ROOT/PORT"
|
|
local SERVICE_CONTAINER_ID="$(cat "$SERVICE_ROOT/ID")"
|
|
local flag key valid_flags
|
|
|
|
local flag_map=(
|
|
"--config-dir: ${SERVICE_ROOT}/config"
|
|
"--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}")"
|
|
"--links: $(service_linked_apps "$SERVICE")"
|
|
"--service-root: ${SERVICE_ROOT}"
|
|
"--status: $(service_status "$SERVICE")"
|
|
"--version: $(service_version "$SERVICE")"
|
|
)
|
|
if [[ -z "$INFO_FLAG" ]]; then
|
|
dokku_log_info2 "Container Information"
|
|
for flag in "${flag_map[@]}"; do
|
|
key="$(echo "${flag#--}" | cut -f1 -d' ' | tr - ' ')"
|
|
dokku_log_verbose "$(printf "%-20s %-25s" "${key^}" "${flag#*: }")"
|
|
done
|
|
else
|
|
local match=false
|
|
for flag in "${flag_map[@]}"; do
|
|
valid_flags="${valid_flags} $(echo "$flag" | cut -d':' -f1)"
|
|
if [[ "$flag" == "${INFO_FLAG}:"* ]]; then
|
|
echo "${flag#*: }" && match=true
|
|
fi
|
|
done
|
|
[[ "$match" == "true" ]] || dokku_log_fail "Invalid flag passed, valid flags:${valid_flags}"
|
|
fi
|
|
}
|
|
|
|
service_is_linked() {
|
|
declare desc="Links a service to an application"
|
|
declare SERVICE="$1" APP="$2"
|
|
update_plugin_scheme_for_app "$APP"
|
|
local SERVICE_URL=$(service_url "$SERVICE")
|
|
local EXISTING_CONFIG=$(config_all "$APP")
|
|
local LINK=$(echo "$EXISTING_CONFIG" | grep "$SERVICE_URL" | cut -d: -f1) || true
|
|
if [[ -z $LINK ]]; then
|
|
dokku_log_warn "Service $SERVICE is not linked to $APP"
|
|
exit 1
|
|
fi
|
|
dokku_log_info1 "Service $SERVICE is linked to $APP"
|
|
}
|
|
|
|
service_link() {
|
|
declare desc="Links a service to an application"
|
|
declare SERVICE="$1" APP="$2"
|
|
update_plugin_scheme_for_app "$APP"
|
|
local SERVICE_URL=$(service_url "$SERVICE")
|
|
local SERVICE_NAME="$(get_service_name "$SERVICE")"
|
|
local SERVICE_ROOT="$PLUGIN_DATA_ROOT/$SERVICE"
|
|
local EXISTING_CONFIG=$(config_all "$APP")
|
|
local LINK=$(echo "$EXISTING_CONFIG" | grep "$SERVICE_URL" | cut -d: -f1) || true
|
|
local SERVICE_DNS_HOSTNAME=$(service_dns_hostname "$SERVICE")
|
|
local LINKS_FILE="$SERVICE_ROOT/LINKS"
|
|
local ALIAS="$PLUGIN_DEFAULT_ALIAS"
|
|
local DEFAULT_ALIAS
|
|
|
|
if [[ -n "$SERVICE_ALIAS" ]]; then
|
|
ALIAS="$SERVICE_ALIAS"
|
|
ALIAS_IN_USE=$(echo "$EXISTING_CONFIG" | grep "${ALIAS}_URL") || true
|
|
[[ -n "$ALIAS_IN_USE" ]] && dokku_log_fail "Specified alias $ALIAS already in use"
|
|
else
|
|
DEFAULT_ALIAS=$(echo "$EXISTING_CONFIG" | grep "${PLUGIN_DEFAULT_ALIAS}_URL") || true
|
|
if [[ -n "$DEFAULT_ALIAS" ]]; then
|
|
ALIAS=$(service_alternative_alias "$EXISTING_CONFIG")
|
|
fi
|
|
[[ -z "$ALIAS" ]] && dokku_log_fail "Unable to use default or generated URL alias"
|
|
fi
|
|
|
|
[[ -n $LINK ]] && dokku_log_fail "Already linked as $LINK"
|
|
touch "$LINKS_FILE"
|
|
echo "$APP" >> "$LINKS_FILE"
|
|
sort "$LINKS_FILE" -u -o "$LINKS_FILE"
|
|
|
|
if declare -f -F add_passed_docker_option > /dev/null; then
|
|
# shellcheck disable=SC2034
|
|
local passed_phases=(build deploy run)
|
|
add_passed_docker_option passed_phases[@] "--link $SERVICE_NAME:$SERVICE_DNS_HOSTNAME"
|
|
else
|
|
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"
|
|
}
|
|
|
|
service_linked_apps() {
|
|
declare desc="Lists all applications linked to a service"
|
|
declare SERVICE="$1"
|
|
local SERVICE_ROOT="$PLUGIN_DATA_ROOT/$SERVICE"
|
|
local LINKS_FILE="$SERVICE_ROOT/LINKS"
|
|
|
|
touch "$LINKS_FILE"
|
|
[[ -z $(< "$LINKS_FILE") ]] && echo '-' && return 0
|
|
|
|
tr '\n' ' ' < "$LINKS_FILE"
|
|
}
|
|
|
|
service_list() {
|
|
declare desc="Lists all services and their status"
|
|
local SERVICES=$(ls "$PLUGIN_DATA_ROOT" 2> /dev/null)
|
|
if [[ -z $SERVICES ]]; then
|
|
dokku_log_warn "There are no $PLUGIN_SERVICE services"
|
|
else
|
|
LIST=""
|
|
if [[ -z "$DOKKU_QUIET_OUTPUT" ]]; then
|
|
LIST="NAME,VERSION,STATUS,EXPOSED PORTS,LINKS\n"
|
|
fi
|
|
|
|
for SERVICE in $SERVICES; do
|
|
LIST+="$SERVICE,$(service_version "$SERVICE"),$(service_status "$SERVICE"),$(service_exposed_ports "$SERVICE"),$(service_linked_apps "$SERVICE")\n"
|
|
done
|
|
printf "%b" "$LIST" | column -t -s,
|
|
fi
|
|
}
|
|
|
|
service_logs() {
|
|
declare desc="Displays logs for a service"
|
|
declare SERVICE="$1" TAIL_FLAG="$2"
|
|
local SERVICE_ROOT="$PLUGIN_DATA_ROOT/$SERVICE"
|
|
local ID=$(cat "$SERVICE_ROOT/ID")
|
|
local RE_INTEGER='^[0-9]+$'
|
|
|
|
DOKKU_LOGS_ARGS="--tail 100"
|
|
if [[ "$TAIL_FLAG" == "-t" ]] || [[ "$TAIL_FLAG" == "--tail" ]]; then
|
|
DOKKU_LOGS_ARGS="--follow"
|
|
fi
|
|
|
|
docker inspect "$ID" &> /dev/null || 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> /dev/null
|
|
}
|
|
|
|
service_parse_args() {
|
|
declare desc="cli arg parser"
|
|
local next_index=1; local skip=false; local args=("$@")
|
|
|
|
for arg in "$@"; do
|
|
shift
|
|
case "$arg" in
|
|
"--alias") set -- "$@" "-a" ;;
|
|
"--config-options") set -- "$@" "-c" ;;
|
|
"--custom-env") set -- "$@" "-C" ;;
|
|
"--database") set -- "$@" "-d" ;;
|
|
"--image-version") set -- "$@" "-I" ;;
|
|
"--image") set -- "$@" "-i" ;;
|
|
"--memory") set -- "$@" "-m" ;;
|
|
"--password") set -- "$@" "-p" ;;
|
|
"--querystring") set -- "$@" "-q" ;;
|
|
"--restart-apps") set -- "$@" "-R" ;;
|
|
"--root-password") set -- "$@" "-r" ;;
|
|
"--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
|
|
case "$opt" in
|
|
a)
|
|
SERVICE_ALIAS="${OPTARG^^}"; export SERVICE_ALIAS="${SERVICE_ALIAS%_URL}"
|
|
;;
|
|
c) export PLUGIN_CONFIG_OPTIONS=$OPTARG
|
|
;;
|
|
C) export SERVICE_CUSTOM_ENV=$OPTARG
|
|
;;
|
|
d) export SERVICE_DATABASE=$OPTARG
|
|
;;
|
|
i) export PLUGIN_IMAGE=$OPTARG
|
|
;;
|
|
I) export PLUGIN_IMAGE_VERSION=$OPTARG
|
|
;;
|
|
m) export SERVICE_MEMORY=$OPTARG
|
|
;;
|
|
p) export SERVICE_PASSWORD=$OPTARG
|
|
;;
|
|
q) export SERVICE_QUERYSTRING=${OPTARG#"?"}
|
|
;;
|
|
R) export SERVICE_RESTART_APPS=$OPTARG
|
|
;;
|
|
r) export SERVICE_ROOT_PASSWORD=$OPTARG
|
|
;;
|
|
u) export SERVICE_USER=$OPTARG
|
|
;;
|
|
esac
|
|
done
|
|
shift "$(( OPTIND - 1 ))" # remove options from positional parameters
|
|
}
|
|
|
|
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"
|
|
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")
|
|
|
|
[[ "${#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
|
|
PORTS=($(cat "$PORT_FILE"))
|
|
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" svendowideit/ambassador > /dev/null
|
|
if [[ "$LOG_FAIL" == "true" ]]; then
|
|
dokku_log_info1 "Service $SERVICE exposed on port(s) [container->host]: $(service_exposed_ports "$SERVICE")"
|
|
fi
|
|
}
|
|
|
|
service_promote() {
|
|
declare desc="Promotes a secondary service to the primary env var"
|
|
declare SERVICE="$1" APP="$2"
|
|
local PLUGIN_DEFAULT_CONFIG_VAR="${PLUGIN_DEFAULT_ALIAS}_URL"
|
|
local EXISTING_CONFIG=$(config_all "$APP")
|
|
update_plugin_scheme_for_app "$APP"
|
|
local SERVICE_URL=$(service_url "$SERVICE")
|
|
local CONFIG_VARS=($(echo "$EXISTING_CONFIG" | grep "$SERVICE_URL" | cut -d: -f1)) || true
|
|
local PREVIOUS_DEFAULT_URL=$(get_url_from_config "$EXISTING_CONFIG" "$PLUGIN_DEFAULT_CONFIG_VAR")
|
|
|
|
[[ -z ${CONFIG_VARS[*]} ]] && dokku_log_fail "Not linked to app $APP"
|
|
[[ ${CONFIG_VARS[*]} =~ $PLUGIN_DEFAULT_CONFIG_VAR ]] && dokku_log_fail "Service $1 already promoted as $PLUGIN_DEFAULT_CONFIG_VAR"
|
|
|
|
local NEW_CONFIG_VARS=""
|
|
if [[ -n $PREVIOUS_DEFAULT_URL ]]; then
|
|
local PREVIOUS_ALIAS=$(echo "$EXISTING_CONFIG" | grep "$PREVIOUS_DEFAULT_URL" | grep -v "$PLUGIN_DEFAULT_CONFIG_VAR") || true
|
|
if [[ -z $PREVIOUS_ALIAS ]]; then
|
|
local ALIAS=$(service_alternative_alias "$EXISTING_CONFIG")
|
|
NEW_CONFIG_VARS+="${ALIAS}_URL=$PREVIOUS_DEFAULT_URL "
|
|
fi
|
|
fi
|
|
local PROMOTE_URL=$(get_url_from_config "$EXISTING_CONFIG" "${CONFIG_VARS[0]}")
|
|
NEW_CONFIG_VARS+="$PLUGIN_DEFAULT_CONFIG_VAR=$PROMOTE_URL"
|
|
|
|
# shellcheck disable=SC2086
|
|
config_set "$APP" $NEW_CONFIG_VARS
|
|
}
|
|
|
|
service_set_alias() {
|
|
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"
|
|
|
|
touch "$ALIAS_FILE"
|
|
echo "$ALIAS" > "$ALIAS_FILE"
|
|
}
|
|
|
|
service_status() {
|
|
declare desc="Displays the status of a service"
|
|
declare SERVICE="$1"
|
|
local SERVICE_ROOT="$PLUGIN_DATA_ROOT/$SERVICE"
|
|
local ID="$(cat "$SERVICE_ROOT/ID")"
|
|
local CONTAINER_STATUS
|
|
|
|
is_container_status "$ID" "Dead" && echo "dead" && return 0
|
|
is_container_status "$ID" "OOMKilled" && echo "oomkilled" && return 0
|
|
is_container_status "$ID" "Paused" && echo "paused" && return 0
|
|
is_container_status "$ID" "Restarting" && echo "restarting" && return 0
|
|
is_container_status "$ID" "Running" && echo "running" && return 0
|
|
|
|
CONTAINER_STATUS=$(docker inspect -f "{{.State.Status}}" "$CID" 2> /dev/null || true)
|
|
[[ -n "$CONTAINER_STATUS" ]] && echo "$CONTAINER_STATUS" && return 0
|
|
echo "missing" && return 0
|
|
}
|
|
|
|
service_stop() {
|
|
declare desc="Stops 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
|
|
|
|
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"
|
|
else
|
|
dokku_log_verbose_quiet "No container exists for $SERVICE"
|
|
fi
|
|
}
|
|
|
|
service_unlink() {
|
|
declare desc="Unlinks an application from a service"
|
|
declare SERVICE="$1" APP="$2"
|
|
update_plugin_scheme_for_app "$APP"
|
|
local SERVICE_URL=$(service_url "$SERVICE")
|
|
local SERVICE_NAME="$(get_service_name "$SERVICE")"
|
|
local EXISTING_CONFIG=$(config_all "$APP")
|
|
local SERVICE_DNS_HOSTNAME=$(service_dns_hostname "$SERVICE")
|
|
local LINK=($(echo "$EXISTING_CONFIG" | grep "$SERVICE_URL" | cut -d: -f1)) || true
|
|
|
|
remove_from_links_file "$SERVICE" "$APP"
|
|
|
|
if declare -f -F add_passed_docker_option > /dev/null; then
|
|
# shellcheck disable=SC2034
|
|
local passed_phases=(build deploy run)
|
|
remove_passed_docker_option passed_phases[@] "--link $SERVICE_NAME:$SERVICE_DNS_HOSTNAME"
|
|
else
|
|
dokku docker-options:remove "$APP" build,deploy,run "--link $SERVICE_NAME:$SERVICE_DNS_HOSTNAME"
|
|
fi
|
|
|
|
[[ -z ${LINK[*]} ]] && dokku_log_fail "Not linked to app $APP"
|
|
config_unset "$APP" "${LINK[*]}"
|
|
}
|
|
|
|
service_version() {
|
|
declare desc="Displays the running version for an image"
|
|
declare SERVICE="$1"
|
|
local SERVICE_NAME="$(get_service_name "$SERVICE")"
|
|
docker inspect -f '{{.Config.Image}}' "$SERVICE_NAME" 2> /dev/null || true
|
|
}
|
|
|
|
update_plugin_scheme_for_app() {
|
|
declare desc="Retrieves the updated plugin scheme"
|
|
declare APP="$1"
|
|
local DATABASE_SCHEME
|
|
|
|
DATABASE_SCHEME=$(config_get "$APP" "${PLUGIN_VARIABLE}_DATABASE_SCHEME" || true)
|
|
PLUGIN_SCHEME=${DATABASE_SCHEME:-$PLUGIN_SCHEME}
|
|
}
|
|
|
|
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"
|
|
return 0
|
|
}
|
|
|
|
is_valid_service_name() {
|
|
declare desc="Validates a service name"
|
|
declare SERVICE="$1"
|
|
[[ -z "$SERVICE" ]] && return 1
|
|
|
|
if [[ "$SERVICE" =~ ^[A-Za-z0-9_]+$ ]]; then
|
|
return 0
|
|
fi
|
|
|
|
return 1
|
|
}
|