0k
/
0k-compose
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
231 Commits
10 Branches
27 Tags
5.0 MiB
 
 
Tree: 1e4e1e047f
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '1e4e1e047f'
${ noResults }
0k-compose/bin/compose

1010 lines
28 KiB
Raw Blame History

#!/bin/bash
## Bash wrap script to launch the ``compose`` docker with right options.
##
##
## Launcher
## - should need minimum requirement to run
## - no shell libs
##
[[ "${BASH_SOURCE[0]}" != "${0}" ]] && SOURCED=true
##
## From kal-shlib
##
ANSI_ESC=$'\e['
md5_compat() {
if get_path md5sum >/dev/null; then
md5_compat() { md5sum | cut -c -32; }
elif get_path md5 >/dev/null; then
md5_compat() { md5; }
else
die "$exname: required GNU or BSD date not found"
fi
md5_compat
}
## output on stdout the next record on stdin separated by a '\0'
next-0() {
local ans IFS=''
read -r -d '' ans &&
echo -n "$ans"
}
array_read-0() {
local elt aname
while true; do
for aname in "$@"; do
declare -n cur="$aname"
elt="$(next-0)" || return 0
cur+=("$elt")
done
done
}
str_pattern_matches() {
local str="$1"
shift
for pattern in "$@"; do
eval "[[ \"$str\" == $pattern ]]" && return 0
done
return 1
}
ansi_color() {
local choice="$1"
if [ "$choice" == "tty" ]; then
if [ -t 1 ]; then
choice="yes"
else
choice="no"
fi
fi
if [ "$choice" != "no" ]; then
SET_COL_CHAR="${ANSI_ESC}${COL_CHAR}G"
SET_COL_STATUS="${ANSI_ESC}${COL_STATUS}G"
SET_COL_INFO="${ANSI_ESC}${COL_INFO}G"
SET_COL_ELT="${ANSI_ESC}${COL_ELT}G"
SET_BEGINCOL="${ANSI_ESC}0G"
UP="${ANSI_ESC}1A"
DOWN="${ANSI_ESC}1B"
LEFT="${ANSI_ESC}1D"
RIGHT="${ANSI_ESC}1C"
SAVE="${ANSI_ESC}7"
RESTORE="${ANSI_ESC}8"
NORMAL="${ANSI_ESC}0m"
GRAY="${ANSI_ESC}1;30m"
RED="${ANSI_ESC}1;31m"
GREEN="${ANSI_ESC}1;32m"
YELLOW="${ANSI_ESC}1;33m"
BLUE="${ANSI_ESC}1;34m"
PINK="${ANSI_ESC}1;35m"
CYAN="${ANSI_ESC}1;36m"
WHITE="${ANSI_ESC}1;37m"
DARKGRAY="${ANSI_ESC}0;30m"
DARKRED="${ANSI_ESC}0;31m"
DARKGREEN="${ANSI_ESC}0;32m"
DARKYELLOW="${ANSI_ESC}0;33m"
DARKBLUE="${ANSI_ESC}0;34m"
DARKPINK="${ANSI_ESC}0;35m"
DARKCYAN="${ANSI_ESC}0;36m"
DARKWHITE="${ANSI_ESC}0;37m"
SUCCESS=$GREEN
WARNING=$YELLOW
FAILURE=$RED
NOOP=$BLUE
ON=$SUCCESS
OFF=$FAILURE
ERROR=$FAILURE
else
SET_COL_CHAR=
SET_COL_STATUS=
SET_COL_INFO=
SET_COL_ELT=
SET_BEGINCOL=
NORMAL=
RED=
GREEN=
YELLOW=
BLUE=
GRAY=
WHITE=
DARKGRAY=
DARKRED=
DARKGREEN=
DARKYELLOW=
DARKBLUE=
DARKPINK=
DARKCYAN=
SUCCESS=
WARNING=
FAILURE=
NOOP=
ON=
OFF=
ERROR=
fi
ansi_color="$choice"
export SET_COL_CHAR SET_COL_STATUS SET_COL_INFO SET_COL_ELT \
SET_BEGINCOL UP DOWN LEFT RIGHT SAVE RESTORE NORMAL \
GRAY RED GREEN YELLOW BLUE PINK CYAN WHITE DARKGRAY \
DARKRED DARKGREEN DARKYELLOW DARKBLUE DARKPINK DARKCYAN \
SUCCESS WARNING FAILURE NOOP ON OFF ERROR ansi_color
}
e() { printf "%s" "$*"; }
warn() { e "${YELLOW}Warning:$NORMAL" "$*"$'\n' >&2 ; }
info() { e "${BLUE}II$NORMAL" "$*"$'\n' >&2 ; }
verb() { [ -z "$VERBOSE" ] || e "$*"$'\n' >&2; }
debug() { [ -z "$DEBUG" ] || e "$*"$'\n' >&2; }
err() { e "${RED}Error:$NORMAL $*"$'\n' >&2 ; }
die() { err "$@" ; exit 1; }
## equivalent of 'xargs echo' with builtins
nspc() {
local content
content=$(printf "%s " $(cat -))
printf "%s" "${content::-1}"
}
get_path() { (
IFS=:
for d in $PATH; do
filename="$d/$1"
[ -f "$filename" -a -x "$filename" ] && {
echo "$d/$1"
return 0
}
done
return 1
) }
depends() {
## Avoid colliding with variables that are created with depends.
local __i __path __new_name
for __i in "$@"; do
if ! __path=$(get_path "$__i"); then
__new_name="$(echo "${__i//-/_}")"
if [ "$__new_name" != "$__i" ]; then
depends "$__new_name"
else
err "dependency check: couldn't find '$__i' required command."
exit 1
fi
else
if ! test -z "$__path" ; then
export "$(echo "${__i//- /__}")"="$__path"
fi
fi
done
}
get_os() {
local uname_output
uname_output="$(uname -s)"
case "${uname_output}" in
Linux*)
if [[ "$(< /proc/version)" == *@(Microsoft|WSL)* ]]; then
e wsl
# elif [[ "$(< /proc/version)" == *"@(microsoft|WSL)"* ]]; then
# e wsl2
else
e linux
fi
;;
Darwin*) e mac;;
CYGWIN*) e cygwin;;
MINGW*) e mingw;;
*) e "UNKNOWN:${uname_output}";;
esac
}
read-0() {
local eof= IFS=''
while [ "$1" ]; do
read -r -d '' -- "$1" || eof=1
shift
done
[ -z "$eof" ]
}
read-0a() {
local eof= IFS=''
while [ "$1" ]; do
IFS='' read -r -d $'\n' -- "$1" || eof=1
shift
done
[ -z "$eof" ]
}
p0() {
printf "%s\0" "$@"
}
cla.normalize() {
local letters arg i
while [ "$#" != 0 ]; do
arg=$1
case "$arg" in
--)
p0 "$@"
return 0
;;
--*=*|-*=*)
shift
set -- "${arg%%=*}" "${arg#*=}" "$@"
continue
;;
--*|-?) :;;
-*)
letters=${arg:1}
shift
i=${#letters}
while ((i--)); do
set -- -${letters:$i:1} "$@"
done
continue
;;
esac
p0 "$arg"
shift
done
}
docker_has_image() {
local image="$1"
images=$(docker images -q "$image" 2>/dev/null) || {
err "docker images call has failed unexpectedly."
return 1
}
[ -n "$images" ]
}
docker_image_id() {
local image="$1"
image_id=$(docker inspect "$image" --format='{{.Id}}') || return 1
echo "$image_id"
}
##
## Compose-core common functions
##
list_compose_vars() {
while read-0a def; do
def="${def##* }"
def="${def%=*}"
p0 "$def"
done < <(declare -p | grep "^declare -x COMPOSE_[A-Z_]\+=\"")
}
get_running_compose_containers() {
## XXXvlab: docker bug: there will be a final newline anyway
docker ps --filter label="compose.service" --format='{{.ID}}'
}
get_volumes_for_container() {
local container="$1"
docker inspect \
--format '{{range $mount := .Mounts}}{{$mount.Source}}{{"\x00"}}{{$mount.Destination}}{{"\x00"}}{{end}}' \
"$container"
}
is_volume_used() {
local volume="$1"
while read container_id; do
while read-0 src dst; do
[ "$src" == "$volume" ] && return 0
done < <(get_volumes_for_container "$container_id")
done < <(get_running_compose_containers)
return 1
}
_MULTIOPTION_REGEX='^((-[a-zA-Z]|--[a-zA-Z0-9-]+)(, )?)+'
_MULTIOPTION_REGEX_LINE_FILTER=$_MULTIOPTION_REGEX'(\s|=)'
##
## compose launcher functions
##
clean_unused_sessions() {
for f in "$SESSION_DIR/"*; do
[ -e "$f" ] || continue
is_volume_used "$f" && continue
## XXXvlab: the second rmdir should not be useful
rm -f "$f" >/dev/null || rmdir "$f" >/dev/null || {
debug "Unexpected session remnants $f"
}
done
}
check_no_links_subdirs() {
local dir
for dir in "$@"; do
[ -d "$dir" ] || continue
if [ -L "$dir" ]; then
err "Unfortunately, this compose launcher do not support yet symlinks in charm-store."
echo " Found symlink in charm-store: $dir" >&2
return 1
fi
[ -e "$dir/metadata.yml" ] && continue
check_no_links_subdirs "$dir"/* || return 1
done
}
## requires docker_run_opts to be set
get_compose_file_opt() {
local compose_docker_image="$1" hash override
shift
image_id=$(docker_image_id "$compose_docker_image")
override=$(get_volume_opt "${docker_run_opts[@]}") || return 1
if [ -n "$override" ]; then
if ! [ -f "$override" ]; then
err "Invalid override of 'compose-core' detected. File '$override' does not exist on host."
return 1
fi
hash=$( { p0 "$image_id"; cat "$override"; } | md5_compat)
else
hash=$(p0 "$image_id" | md5_compat)
fi
_get_compose_file_opt "$hash" "$override" "$@" || return 1
}
_get_compose_file_opt() {
local hash_bin="$1" override="$2" \
cache_file="$COMPOSE_LAUNCHER_CACHE/$FUNCNAME.cache.$(p0 "$@" | md5_compat)"
if [ -e "$cache_file" ]; then
cat "$cache_file" &&
touch "$cache_file" || return 1
return 0
fi
shift 2
DC_MATCH_MULTI=$(get_compose_multi_opts_list "$hash_bin" "$override") || return 1
DC_MATCH_SINGLE=$(get_compose_single_opts_list "$hash_bin" "$override") || return 1
while read-0 arg; do
case "$arg" in
"-f"|"--file")
read-0 value
e "$value"
return 0
;;
--*|-*)
if str_pattern_matches "$arg" $DC_MATCH_MULTI; then
read-0 value
opts+=("$arg" "$value")
shift
elif str_pattern_matches "$arg" $DC_MATCH_SINGLE; then
opts+=("$arg")
else
debug "Unknown option '$arg'. Didn't manage to pre-parse correctly options."
return 1
fi
;;
*)
return 1
;;
esac
done < <(cla.normalize "$@") | tee "$cache_file"
}
replace_compose_file_opt() {
local compose_docker_image="$1" hash override
shift
image_id=$(docker_image_id "$compose_docker_image")
override=$(get_volume_opt "${docker_run_opts[@]}") || return 1
if [ -n "$override" ]; then
if ! [ -f "$override" ]; then
err "Invalid override of 'compose-core' detected. File '$override' does not exist on host."
return 1
fi
hash=$( { p0 "$image_id"; cat "$override"; } | md5_compat)
else
hash=$(p0 "$image_id" | md5_compat)
fi
_replace_compose_file_opt "$hash" "$override" "$@" || return 1
}
_replace_compose_file_opt() {
local hash_bin="$1" override="$2" \
cache_file="$COMPOSE_LAUNCHER_CACHE/$FUNCNAME.cache.$(p0 "$@" | md5_compat)"
if [ -e "$cache_file" ]; then
cat "$cache_file" &&
touch "$cache_file" || return 1
return 0
fi
debug "Replacing '-f|--file' argument in command line."
shift 2
DC_MATCH_MULTI=$(get_compose_multi_opts_list "$hash_bin" "$override") || return 1
DC_MATCH_SINGLE=$(get_compose_single_opts_list "$hash_bin" "$override") || return 1
args=()
while read-0 arg; do
case "$arg" in
"-f"|"--file")
read-0 value
args+=("$arg" "${value##*/}")
;;
--*|-*)
if str_pattern_matches "$arg" $DC_MATCH_MULTI; then
read-0 value
args+=("$arg" "$value")
shift
elif str_pattern_matches "$arg" $DC_MATCH_SINGLE; then
args+=("$arg")
else
err "Unknown option '$arg'. Didn't manage to pre-parse correctly options."
return 1
fi
;;
*)
args+=("$arg")
while read-0 arg; do
args+=("$arg")
done
;;
esac
done < <(cla.normalize "$@")
p0 "${args[@]}" | tee "$cache_file"
}
get_compose_opts_list() {
local hash_bin="$1" override="$2" \
cache_file="$COMPOSE_LAUNCHER_CACHE/$FUNCNAME.cache.$1"
if [ -e "$cache_file" ]; then
cat "$cache_file" &&
touch "$cache_file" || return 1
return 0
fi
debug "Pre-Launching docker to retrieve command line argument definitions."
opts_list=()
if [ -n "$override" ]; then
opts_list+=("-v" "$override:/usr/local/bin/compose-core:ro")
fi
compose_opts_help=$(docker run "${opts_list[@]}" "$COMPOSE_DOCKER_IMAGE" --help 2>/dev/null)
echo "$compose_opts_help" |
grep '^Options:' -A 20000 |
tail -n +2 |
{ cat ; echo; } |
grep -E -m 1 "^\S*\$" -B 10000 |
head -n -1 |
grep -E "^\s+-" |
sed -r 's/\s+((((-[a-zA-Z]|--[a-zA-Z0-9-]+)( [A-Z=]+|=[^ ]+)?)(, )?)+)\s+.*$/\1/g' |
tee "$cache_file" || return 1
}
multi_opts_filter() {
grep -E "$_MULTIOPTION_REGEX_LINE_FILTER" |
sed -r "s/^($_MULTIOPTION_REGEX)(\s|=).*$/\1/g" |
tr ',' "\n" | nspc
}
single_opts_filter() {
grep -E -v "$_MULTIOPTION_REGEX_LINE_FILTER" |
tr ',' "\n" | nspc
}
get_compose_multi_opts_list() {
local hash_bin="$1" override="$2" \
cache_file="$COMPOSE_LAUNCHER_CACHE/$FUNCNAME.cache.$1" opts_list
if [ -e "$cache_file" ]; then
cat "$cache_file" &&
touch "$cache_file" || return 1
return 0
fi
opts_list=$(get_compose_opts_list "$hash_bin" "$override") || return 1
echo "$opts_list" | multi_opts_filter | tee "$cache_file"
}
get_compose_single_opts_list() {
local hash_bin="$1" override="$2" \
cache_file="$COMPOSE_LAUNCHER_CACHE/$FUNCNAME.cache.$1" opts_list
if [ -e "$cache_file" ]; then
cat "$cache_file" &&
touch "$cache_file" || return 1
return 0
fi
opts_list=$(get_compose_opts_list "$hash_bin" "$override") || return 1
echo "$opts_list" | single_opts_filter | tee "$cache_file"
}
get_volume_opt() {
local cache_file="$COMPOSE_LAUNCHER_CACHE/$FUNCNAME.cache.$(p0 "$@" | md5_compat)"
if [ -e "$cache_file" ]; then
cat "$cache_file" &&
touch "$cache_file" || return 1
return 0
fi
while [ "$#" != 0 ]; do
case "$1" in
"-v")
dst="${2#*:}"
dst="${dst%:*}"
if [ "$dst" == "/usr/local/bin/compose-core" ]; then
override="${2%%:*}"
debug "Override of compose-core found: $override"
fi
shift;;
"-e"|"-w")
shift;;
*)
:
;;
esac
shift
done
{ [ -n "$override" ] && echo "$override"; } | tee "$cache_file"
}
get_tz() {
if [ -n "$TZ" ]; then
:
elif [ -n "$COMPOSE_LOCAL_ROOT" ] && ## previous compose run
[ -e "$COMPOSE_LOCAL_ROOT/etc/timezone" ]; then
read -r TZ < "$COMPOSE_LOCAL_ROOT/etc/timezone"
elif [ -e "/etc/timezone" ]; then ## debian host system timezone
read -r TZ < /etc/timezone
elif [ -e "/etc/localtime" ]; then ## redhat and macosx sys timezone
local fullpath dirname
fullpath="$(readlink -f /etc/localtime)"
dirname="${fullpath%/*}"
TZ=${TZ:-${fullpath##*/}/${dirname##*/}}
else
err "Timezone not found nor inferable !"
echo " compose relies on '/etc/timezone' or '/etc/localtime' to be present " >&2
echo " so as to ensure same timezone for all containers that need it." >&2
echo >&2
echo " You can set a default value for compose by create issuing:" >&2
echo >&2
if [ -n "$COMPOSE_LOCAL_ROOT" ] && [ "$UID" != 0 ]; then
echo " mkdir -p $COMPOSE_LOCAL_ROOT/etc &&" >&2
echo " echo \"Europe/Paris\" > $COMPOSE_LOCAL_ROOT/etc/timezone" >&2
else
echo " echo \"Europe/Paris\" > /etc/timezone" >&2
fi
echo >&2
echo " Of course, you can change 'Europe/Paris' value by any other valid timezone." >&2
echo " timezone." >&2
echo >&2
echo " Notice you can also use \$TZ environment variable, but the value" >&2
echo " will be necessary each time you launch compose." >&2
echo >&2
return 1
fi
e "$TZ"
}
pretty_print() {
while [ "$#" != 0 ]; do
case "$1" in
"-v"|"-e"|"-w")
e "$1" "$2" "\\"$'\n'
shift;;
*)
e "$1 ";;
esac
shift
done
}
win_env() { "$CMD" /c "<nul set /p=%${1}%" 2>/dev/null; }
wsl_path_env() { wslpath "$(win_env "${1}")"; }
set_os() {
OS="$(get_os)"
case "$OS" in
linux)
COMPOSE_LOCAL_ROOT=${COMPOSE_LOCAL_ROOT:-"$HOME/.compose"}
COMPOSE_VAR=${COMPOSE_VAR:-/var/lib/compose}
COMPOSE_CACHE=${COMPOSE_CACHE:-/var/cache/compose}
DATASTORE=${DATASTORE:-/srv/datastore/data}
CONFIGSTORE=${CONFIGSTORE:-/srv/datastore/config}
if [ "$UID" == 0 ]; then
SESSION_DIR=${SESSION_DIR:-"$COMPOSE_VAR"/sessions}
CHARM_STORE=${CHARM_STORE:-/srv/charm-store}
TZ_PATH=${TZ_PATH:-"$COMPOSE_VAR"/timezones}
COMPOSE_LAUNCHER_CACHE=${COMPOSE_LAUNCHER_CACHE:-"$COMPOSE_CACHE"}
else
SESSION_DIR=${SESSION_DIR:-"$COMPOSE_LOCAL_ROOT"/sessions}
CHARM_STORE=${CHARM_STORE:-"$HOME"/.charm-store}
TZ_PATH=${TZ_PATH:-"$COMPOSE_LOCAL_ROOT"/timezones}
COMPOSE_LAUNCHER_CACHE=${COMPOSE_LAUNCHER_CACHE:-"$COMPOSE_LOCAL_ROOT"/cache}
fi
;;
mac)
COMPOSE_LOCAL_ROOT=${COMPOSE_LOCAL_ROOT:-"$HOME/.compose"}
COMPOSE_VAR=${COMPOSE_VAR:-"$COMPOSE_LOCAL_ROOT"/lib}
COMPOSE_CACHE=${COMPOSE_CACHE:-"$COMPOSE_LOCAL_ROOT"/cache}
SESSION_DIR=${SESSION_DIR:-"$COMPOSE_LOCAL_ROOT"/sessions}
DATASTORE=${DATASTORE:-"$COMPOSE_LOCAL_ROOT"/data}
CONFIGSTORE=${CONFIGSTORE:-"$COMPOSE_LOCAL_ROOT"/config}
CHARM_STORE=${CHARM_STORE:-"$HOME"/.charm-store}
TZ_PATH=${TZ_PATH:-"$COMPOSE_LOCAL_ROOT"/timezones}
COMPOSE_LAUNCHER_CACHE=${COMPOSE_LAUNCHER_CACHE:-"$COMPOSE_LOCAL_ROOT"/cache}
;;
wsl)
type -p cmd.exe >/dev/null || {
die "cmd.exe is not found in \$PATH."
}
CMD=$(type -p cmd.exe >/dev/null) || {
for p in {/mnt,}/c/WINDOWS/SYSTEM32; do
if [ -x "$p"/cmd.exe ]; then
CMD="$p"/cmd.exe
fi
done
if [ -z "$CMD" ]; then
die "cmd.exe is not found in \$PATH." \
"And could not find it in standard directories."
fi
}
WIN_HOME="$(wsl_path_env UserProfile)"
WIN_PROGRAM_FILES="$(wsl_path_env ProgramFiles)"
COMPOSE_LAUNCHER_APP_DIR="$WIN_PROGRAM_FILES/Compose"
COMPOSE_LOCAL_ROOT=${COMPOSE_LOCAL_ROOT:-"$WIN_HOME/AppData/Local/Compose/Launcher"}
COMPOSE_VAR=${COMPOSE_VAR:-"$WIN_HOME/AppData/Local/Compose/lib"}
COMPOSE_CACHE=${COMPOSE_CACHE:-"$WIN_HOME/AppData/Local/Compose/cache"}
DATASTORE=${DATASTORE:-"$WIN_HOME/AppData/Local/Compose/data"}
CONFIGSTORE=${CONFIGSTORE:-"$WIN_HOME/AppData/Local/Compose/config"}
mkdir -p "$COMPOSE_VAR" "$COMPOSE_CACHE" "$DATASTORE" "$CONFIGSTORE" || return 1
SESSION_DIR=${SESSION_DIR:-"$COMPOSE_LOCAL_ROOT"/sessions}
CHARM_STORE=${CHARM_STORE:-"$COMPOSE_LAUNCHER_APP_DIR/charm-store"}
TZ_PATH=${TZ_PATH:-"$COMPOSE_LOCAL_ROOT"/timezones}
COMPOSE_LAUNCHER_CACHE=${COMPOSE_LAUNCHER_CACHE:-"$COMPOSE_LOCAL_ROOT"/cache}
;;
*)
echo "System '$os' not supported yet." >&2
return 1
;;
esac
}
mk_docker_run_options() {
## Order matters, files get to override vars
compose_config_files=(
## DEFAULT LINUX VARS
/etc/default/charm
/etc/default/datastore
/etc/default/compose
## COMPOSE SYSTEM-WIDE FILES
/etc/compose.conf
/etc/compose.local.conf
/etc/compose/local.conf
## COMPOSE USER FILES
~/.compose/etc/local.conf
~/.compose.conf
)
set_os || return 1
docker_run_opts=("-v" "/var/run/docker.sock:/var/run/docker.sock")
##
## Load config files
##
if [ -z "$DISABLE_SYSTEM_CONFIG_FILE" ]; then
## XXXvlab: should provide YML config opportunities in possible parent dirs ?
## userdir ? and global /etc/compose.yml ?
for cfgfile in "${compose_config_files[@]}"; do
[ -e "$cfgfile" ] || continue
docker_run_opts+=("-v" "$cfgfile:$cfgfile:ro")
. "$cfgfile"
done
else
docker_run_opts+=("-e" "DISABLE_SYSTEM_CONFIG_FILE=$DISABLE_SYSTEM_CONFIG_FILE")
fi
mkdir -p "$COMPOSE_LAUNCHER_CACHE" || return 1
## get TZ value and prepare TZ_PATH
TZ=$(get_tz) || return 1
mkdir -p "${TZ_PATH}"
TZ_PATH="${TZ_PATH}/$(e "$TZ" | sha256sum | cut -c 1-8)" || return 1
[ -e "$TZ_PATH" ] || e "$TZ" > "$TZ_PATH"
## CACHE/DATA DIRS
docker_run_opts+=("-v" "$COMPOSE_VAR:/var/lib/compose")
docker_run_opts+=("-v" "$COMPOSE_CACHE:/var/cache/compose")
docker_run_opts+=("-v" "$TZ_PATH:/etc/timezone:ro")
##
## Checking vars
##
## CHARM_STORE
[ -e "$CHARM_STORE" ] || mkdir -p "$CHARM_STORE" || return 1
[ -L "$CHARM_STORE" ] && {
CHARM_STORE=$(readlink -f "$CHARM_STORE") || return 1
}
docker_run_opts+=(
"-v" "$CHARM_STORE:/srv/charm-store:ro"
"-e" "CHARM_STORE=/srv/charm-store"
"-e" "HOST_CHARM_STORE=$CHARM_STORE"
)
check_no_links_subdirs "$CHARM_STORE"/* || return 1
## DEFAULT_COMPOSE_FILE
if [ "${DEFAULT_COMPOSE_FILE+x}" ]; then
DEFAULT_COMPOSE_FILE=$(realpath "$DEFAULT_COMPOSE_FILE")
dirname=$(dirname "$DEFAULT_COMPOSE_FILE")/
if [ -e "${DEFAULT_COMPOSE_FILE}" ]; then
docker_run_opts+=("-v" "$dirname:$dirname:ro")
fi
fi
## COMPOSE_YML_FILE
if [ "${COMPOSE_YML_FILE+x}" ]; then
if [ -e "${COMPOSE_YML_FILE}" ]; then
docker_run_opts+=(
"-v" "$COMPOSE_YML_FILE:/tmp/compose.yml:ro"
"-e" "COMPOSE_YML_FILE=/tmp/compose.yml"
"-e" "HOST_COMPOSE_YML_FILE=/tmp/compose.yml"
)
fi
fi
## DATASTORE and CONFIGSTORE
docker_run_opts+=(
"-v" "$DATASTORE:/srv/datastore/data:rw"
"-e" "DATASTORE=/srv/datastore/data"
"-e" "HOST_DATASTORE=$DATASTORE"
"-v" "$CONFIGSTORE:/srv/datastore/config:rw"
"-e" "CONFIGSTORE=/srv/datastore/config"
"-e" "HOST_CONFIGSTORE=$CONFIGSTORE"
)
#docker_run_opts+=("-v" "$HOME/.docker:/root/.docker")
COMPOSE_DOCKER_IMAGE=${COMPOSE_DOCKER_IMAGE:-docker.0k.io/compose}
docker_run_opts+=("-e" "COMPOSE_DOCKER_IMAGE=$COMPOSE_DOCKER_IMAGE")
if ! docker_has_image "$COMPOSE_DOCKER_IMAGE"; then
docker pull "$COMPOSE_DOCKER_IMAGE" || return 1
fi
## SSH config
# docker_run_opts+=(
# "-v" "$HOME/.ssh:/root/.ssh:ro"
# "-v" "/etc/ssh:/etc/ssh:ro"
# )
COMPOSE_LAUNCHER_BIN=$(readlink -f "${BASH_SOURCE[0]}")
docker_run_opts+=("-v" "$COMPOSE_LAUNCHER_BIN:/usr/local/bin/compose")
while read-0 var; do
case "$var" in
COMPOSE_YML_FILE|COMPOSE_LAUNCHER_BIN|COMPOSE_DOCKER_IMAGE|\
COMPOSE_LAUNCHER_OPTS|COMPOSE_VAR|COMPOSE_CACHE)
:
;;
*)
docker_run_opts+=("-e" "$var=${!var}")
;;
esac
done < <(list_compose_vars)
compose_file=$(get_compose_file_opt "$COMPOSE_DOCKER_IMAGE" "$@") || return 1
if [ -z "$compose_file" ]; then
## Find a compose.yml in parents
debug "No config file specified on command line arguments"
debug "Looking for 'compose.yml' in self and parents.."
if parent=$(while true; do
[ -e "./compose.yml" ] && {
echo "$PWD"
exit 0
}
[ "$PWD" == "/" ] && return 1
cd ..
done
); then
compose_file="$(realpath "$parent"/"compose.yml")"
debug " .. found '$compose_file'"
else
debug " .. not found."
fi
fi
if [ -n "$compose_file" ]; then
if ! [ -f "$compose_file" ]; then
die "Specified compose file '$compose_file' not found."
fi
compose_file="$(realpath "$compose_file")"
parent_dir="${compose_file%/*}"
docker_path=/var/lib/compose/root/${parent_dir##*/}/${compose_file##*/}
docker_run_opts+=(
"-e" "COMPOSE_YML_FILE=${compose_file##*/}"
"-v" "${compose_file}:${docker_path}:ro"
"-w" "${docker_path%/*}"
)
else
docker_path=/var/lib/compose/root
docker_run_opts+=(
"-w" "${docker_path}"
)
fi
clean_unused_sessions
filename=$(mktemp -p /tmp/ -t launch_opts-XXXXXXXXXXXXXXXX)
p0 "${docker_run_opts[@]}" > "$filename"
sha=$(sha256sum "$filename")
sha=${sha:0:64}
src="$SESSION_DIR/$UID-$sha"
dest="/var/lib/compose/sessions/$UID-$sha"
{
p0 "-v" "$SESSION_DIR/$UID-$sha:$dest:ro"
p0 "-e" "COMPOSE_LAUNCHER_OPTS=$dest"
p0 "-e" "COMPOSE_LAUNCHER_BIN=$COMPOSE_LAUNCHER_BIN"
} >> "$filename"
mkdir -p "$SESSION_DIR" || return 1
mv -f "$filename" "$SESSION_DIR/$UID-$sha" || return 1
e "$SESSION_DIR/$UID-$sha"
if [ -n "$DEBUG" ]; then
echo "${WHITE}Environment:${NORMAL}"
echo " COMPOSE_DOCKER_IMAGE: $COMPOSE_DOCKER_IMAGE"
echo " CHARM_STORE: $CHARM_STORE"
echo " DATASTORE: $DATASTORE"
echo " CONFIGSTORE: $CONFIGSTORE"
echo " COMPOSE_VAR: $COMPOSE_VAR"
echo " COMPOSE_CACHE: $COMPOSE_CACHE"
echo " COMPOSE_LAUNCHER_CACHE: $COMPOSE_LAUNCHER_CACHE"
echo " SESSION_DIR: $SESSION_DIR"
echo " TZ_PATH: $TZ_PATH"
fi >&2
}
run() {
local os docker_run_opts
docker_run_opts=()
if [ -z "$COMPOSE_LAUNCHER_OPTS" ]; then
COMPOSE_LAUNCHER_OPTS="$(mk_docker_run_options "$@")" || return 1
fi
while read-0 opt; do
docker_run_opts+=("$opt")
## catch COMPOSE_DOCKER_IMAGE
if [[ "$env" == "true" && "$opt" == "COMPOSE_DOCKER_IMAGE="* ]]; then
COMPOSE_DOCKER_IMAGE=${opt##COMPOSE_DOCKER_IMAGE=}
elif [ "$opt" == "-e" ]; then
env=true
else
env=
fi
done < <(cat "$COMPOSE_LAUNCHER_OPTS")
set_os
array_read-0 cmd_args < <(replace_compose_file_opt "$COMPOSE_DOCKER_IMAGE" "$@")
set -- "${cmd_args[@]}"
[ -t 0 ] && docker_run_opts+=("-i")
[ -t 1 ] && docker_run_opts+=("-t")
if [ -n "$DEBUG" ] || [ -n "$DRY_RUN" ]; then
debug "${WHITE}Launching:${NORMAL}"
echo "docker run --rm \\"
pretty_print "${docker_run_opts[@]}" | sed -r 's/^/ /g;s/([^\])$/\1\\\n/g'
if [ -z "$ENTER" ]; then
echo " ${COMPOSE_DOCKER_IMAGE} \\"
echo " " "$@"
else
echo " --entrypoint bash \\"
echo " ${COMPOSE_DOCKER_IMAGE}"
fi
fi | { if [ -n "$DEBUG" ]; then sed -r 's/^/ /g'; else cat; fi } >&2
if [ -z "$DRY_RUN" ]; then
debug "${WHITE}Execution:${NORMAL}"
if [ -z "$ENTER" ]; then
exec docker run --rm "${docker_run_opts[@]}" "${COMPOSE_DOCKER_IMAGE}" "$@"
else
exec docker run --rm "${docker_run_opts[@]}" \
--entrypoint bash \
"${COMPOSE_DOCKER_IMAGE}"
fi
fi
}
[ -n "$SOURCED" ] && return 0
##
## Code
##
depends docker cat readlink sed realpath tee sed grep tail
ansi_color "${ansi_color:-tty}"
run "$@"