0k
/
0k-charms
6
3
Fork 2
Code Issues 11 Pull Requests 5 Releases Wiki Activity
Browse Source

new: [docker-host] manage static and deb install of ``docker``

master
Valentin Lab 2 weeks ago
parent
8306f1d185
commit
34ef339144
1 changed files with 339 additions and 60 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 399
      precise/host/hooks/install.d/60-docker.sh

399
precise/host/hooks/install.d/60-docker.sh
View File

@ -3,33 +3,61 @@
## Set NO_DOCKER_RESTART to prevent restarting docker after upgrade.
## Set ALLOW_DOCKER_CHANGE to allow change your docker version.
## Set TARGET_DOCKER_VERSION to force a version (use cautiously!)
exname=${0##*/}
if [ "$exname" == "bash" ]; then
## probably launched through ``charm``
if [ -n "$CHARM_NAME" ]; then
exname="charm/${CHARM_NAME}"
else
echo "Error: cannot determine script name" >&2
echo " Please either run this script directly or through \`\`charm\`\`" >&2
exit 1
fi
fi
for bin in apt-get grep dpkg file lsb_release; do
if ! type -p "$bin" >/dev/null; then
echo "Error: \`\`$bin\`\` not found" >&2
exit 1
fi
done
STATIC_DOCKER_URL="https://download.docker.com/linux/static/stable/x86_64"
distro=$(lsb_release -is)
release=$(lsb_release -rs)
unsupported=
target_version=${TARGET_DOCKER_VERSION:-24}
if [ -z "$TARGET_DOCKER_VERSION" ]; then
case "$distro" in
Debian)
case "$release" in
10|11|12) target_version=24;;
*) target_version=19;;
esac
;;
Ubuntu)
case "$release" in
22.04) target_version=24;;
*) target_version=19;;
esac
;;
*) target_version=17;;
esac
else
target_version="$TARGET_DOCKER_VERSION"
declare -A distro_supported_version=(
[Debian]="9 10 11 12"
[Ubuntu]="20.04 22.04"
)
if [ "$distro" == "Debian" ]; then
release=${release%%.*}
fi
if [ -z "${distro_supported_version[$distro]}" ] ||
[[ " ${distro_supported_version[$distro]} " != *" $release "* ]]; then
echo "Warning: possibly unsupported distribution/version $distro $release" >&2
echo " Supported distributions and versions:" >&2
for dist in "${!distro_supported_version[@]}"; do
echo -n " $dist: " >&2
## comma separated list
versions="${distro_supported_version[$dist]}"
versions="${versions// /, }"
echo "$versions" >&2
done
unsupported=1
fi
version_gt() { test "$(echo -e "$@" | tr " " "\n" | sort -V | head -n 1)" != "$1"; }
just_installed=
if ! type -p docker >/dev/null; then
if ! docker_bin=$(type -p docker); then
echo "Installing docker..."
type -p curl >/dev/null ||
apt-get install -y curl </dev/null
@ -38,6 +66,38 @@ if ! type -p docker >/dev/null; then
just_installed=1
fi
is_static_docker() {
local docker_bin=$1
# check if this is a link
[[ -L "$docker_bin" ]] && docker_bin=$(readlink -f "$docker_bin")
## XXXvlab: We need to handle a special case that happens on some systems
## having installed 0k-docker package that divert the docker
## binary to a shell script that then calls docker
## check if this a shell script (using file)
if file "$docker_bin" | grep -q shell; then
echo "INFO: using a shell script for docker in '$docker_bin'" >&2
## is the script mentioning "/usr/bin/docker" ?
if grep -q '/usr/bin/docker' "$docker_bin"; then
echo "INFO: docker script is calling '/usr/bin/docker'" >&2
docker_bin=/usr/bin/docker
else
echo "ERROR: cannot determine docker binary from script '$docker_bin'" >&2
return 1
fi
fi
[[ "$(ldd "$docker_bin")" == *not\ a\ dynamic\ executable* ]]
}
is_static_docker_install=0
if is_static_docker "$docker_bin"; then
echo "INFO: docker version is static" >&2
is_static_docker_install=1
fi
read docker_client_version docker_server_version < <(
docker version --format '{{.Client.Version}} {{.Server.Version}}'
)
@ -51,63 +111,282 @@ if [ "$docker_client_version" != "$docker_server_version" ]; then
mismatch_client_server=1
fi
distrib_available_version="$(apt-cache madison docker-ce |
cut -f 2 -d \| |
grep "$target_version" |
head -n 1 | xargs echo)"
distrib_available_versions=$(apt-cache madison docker-ce | cut -f 2 -d "|" | sort -V)
deb_version_to_docker_version() {
local deb_version=$1
local docker_version
docker_version="${deb_version%%~*}"
docker_version="${docker_version%-*}"
docker_version="${docker_version#*:}"
echo "$docker_version"
}
declare -A docker_version_to_deb_version=()
for deb_version in $distrib_available_versions; do
docker_version=$(deb_version_to_docker_version "$deb_version")
docker_version_to_deb_version["$docker_version"]="$deb_version"
done
## expand docker version to one that is available in deb on the repository
candidate_deb_target_version=$(
echo "${!docker_version_to_deb_version[@]}" |
tr ' ' '\n' | grep "^${target_version}[^\d]" | sort -V | tail -n 1
)
if [ -z "$candidate_deb_target_version" ]; then
## No deb package seems to satisfy the target version
# Fetch the HTML content and filter out the versions
available_docker_static_versions=$(
curl -sL "$STATIC_DOCKER_URL" | grep -oP 'docker-\d+\.\d+\.\d+\.tgz' |
cut -d'-' -f2 | cut -d'.' -f1,2,3 | sort -uV
)
candidate_target_version=$(
echo "$available_docker_static_versions" |
grep "^${target_version}" | sort -V | tail -n 1
)
if [ -z "$candidate_target_version" ]; then
echo "ERROR: no docker version matching '${target_version}' available" >&2
echo " Available versions for $distro $release:" >&2
all_versions=(
$(
{
echo "${!docker_version_to_deb_version[@]}" | tr ' ' '\n'
echo "$available_docker_static_versions"
} | cut -f 1,2 -d. | sort -uV
)
)
for version in "${all_versions[@]}"; do
candidate_deb_target_version=$(
echo "${!docker_version_to_deb_version[@]}" |
tr ' ' '\n' | grep "^${version}[^\d]" | sort -V | tail -n 1
)
if [ -n "$candidate_deb_target_version" ]; then
msg=" with deb"
else
msg=" with static version"
fi
printf " - %-10s %s\n" "$version" "$msg" >&2
done
echo >&2
echo " 1) You may need to contact your system administrator to upgrade this script." >&2
echo " 2) Meanwhile, if you know what you are doing, you can set yourself a target version" >&2
echo " by setting TARGET_DOCKER_VERSION." >&2
exit 1
fi
echo "INFO: target docker version $target_version is not supported by distrib" >&2
echo " Binary static version $candidate_target_version of docker will be used" >&2
max_docker_version_available=
for docker_version in ${!docker_version_to_deb_version[@]}; do
if version_gt "$docker_version" "$target_version"; then
continue
fi
if version_gt "$docker_version" "$max_docker_version_available"; then
max_docker_version_available="$docker_version"
fi
done
if [ -z "$max_docker_version_available" ]; then
## use lowest version available
echo "INFO: no inferior docker version available in deb repository" \
"to satisfy target version $target_version" >&2
max_docker_version_available=$(
echo "${!docker_version_to_deb_version[@]}" |
tr ' ' '\n' |
sort -V |
head -n 1
)
if [ -z "$max_docker_version_available" ]; then
echo "ERROR: no docker version available in deb repository" >&2
exit 1
fi
echo "INFO: using lowest docker version available in deb repository" >&2
fi
echo "INFO: closest docker version supported by $distro $release:" \
"$(deb_version_to_docker_version "$max_docker_version_available")" >&2
target_deb_version="${docker_version_to_deb_version[$max_docker_version_available]}"
target_version=$candidate_target_version
echo "INFO: target maximal deb version: '$target_deb_version' (docker version: $(
deb_version_to_docker_version "$target_deb_version"
))" >&2
need_static=1
else
## a deb package is available to satisfy the target version
target_deb_version="${docker_version_to_deb_version[$candidate_deb_target_version]}"
target_version=$candidate_deb_target_version
echo "INFO: target docker deb version: '$target_deb_version' " \
"(docker version: $candidate_deb_target_version)" >&2
need_static=0
fi
current_docker_ce_package_version=$(
dpkg -s docker-ce | grep '^Version:' | cut -f 2 -d ' '
)
current_docker_ce_cli_package_version=$(
dpkg -s docker-ce-cli | grep '^Version:' | cut -f 2 -d ' '
)
## Install deb version if required
cleaned_distrib_available_version="${distrib_available_version%%~*}"
cleaned_distrib_available_version="${distrib_available_version%-*}"
cleaned_distrib_available_version="${cleaned_distrib_available_version#*:}"
if [ -z "$mismatch_client_server" ] &&
[[ "$docker_client_version" == "$cleaned_distrib_available_version" ]]; then
## current and target versions match, no upgrade needed
echo "INFO: recommended target docker version $docker_client_version already installed" >&2
echo " To set a different target version, set TARGET_DOCKER_VERSION" >&2
exit 0
[[ "$current_docker_ce_cli_package_version" == "$target_deb_version" ]] &&
[[ "$current_docker_ce_package_version" == "$target_deb_version" ]]; then
if [[ "$need_static" == 0 ]] && [[ "$is_static_docker_install" == 0 ]]; then
## current and target versions match, no upgrade needed
echo "INFO: recommended target deb docker version $target_version already installed" >&2
echo " To set a different target version, set TARGET_DOCKER_VERSION" >&2
exit 0
fi
## Check static version and current version matches the target_version
if [[ "$need_static" == 1 ]] && [[ "$is_static_docker_install" == 1 ]] &&
[[ "$target_version" == "$docker_server_version" ]]; then
## current and target versions match, no upgrade needed
echo "INFO: recommended target deb and static docker version $target_version already installed" >&2
echo " To set a different target version, set TARGET_DOCKER_VERSION" >&2
exit 0
fi
fi
## Should we skip upgrade?
if [ -z "$just_installed" ] && [ -z "$ALLOW_DOCKER_CHANGE" ]; then
if [ -n "$distrib_available_version" ]; then
if [ -z "$mismatch_client_server" ]; then
## get current version for docker-ce debian package installed
current_debian_package_version="$(dpkg -s docker-ce | grep '^Version:' | cut -f 2 -d ' ')"
echo "INFO: docker recommended version available (current: $current_debian_package_version => recommended: $distrib_available_version)" >&2
echo "WARN: You are not on the recommended setup (target docker version: $target_version)" >&2
if [[ "$current_docker_ce_package_version" != "$target_deb_version" ]]; then
echo "INFO: docker-ce recommended deb version available" >&2
echo " current: $current_docker_ce_package_version" >&2
echo " recommended: $target_deb_version" >&2
fi
if [[ "$current_docker_ce_cli_package_version" != "$target_deb_version" ]]; then
echo "INFO: docker-ce-cli recommended deb version available" >&2
echo " current: $current_docker_ce_cli_package_version" >&2
echo " recommended: $target_deb_version" >&2
fi
if [[ "$need_static" != "$is_static_docker_install" ]]; then
if [[ "$need_static" == 1 ]]; then
echo "INFO: docker static version recommended to achieved version $target_version" >&2
else
current_docker_ce_package_version="$(dpkg -s docker-ce | grep '^Version:' | cut -f 2 -d ' ')"
current_docker_ce_cli_package_version="$(dpkg -s docker-ce-cli | grep '^Version:' | cut -f 2 -d ' ')"
echo "WARNING: docker recommended version available (recommended: $distrib_available_version)" >&2
echo " And your client ($current_docker_ce_cli_package_version) and server ($current_docker_ce_package_version) versions differ." >&2
echo "INFO: docker deb version recommended, fulfilled by deb version $target_deb_version" >&2
fi
echo " To change version, run this script with ALLOW_DOCKER_CHANGE=1" >&2
else
echo "WARNING: your docker version does match target recommended version" >&2
echo " And your distribution does not package target version." >&2
echo " - Your distribution: $distro $release" >&2
echo " - Current docker version: $docker_client_version" >&2
echo " - Target recommended version: ${target_version}*" >&2
fi
echo "INFO: To change version, run this script with ALLOW_DOCKER_CHANGE=1" >&2
exit 0
fi
if [ -z "$distrib_available_version" ]; then
echo "ERROR: no docker version matching '${target_version}*' available for your distribution" >&2
echo " Your distribution: $distro $release" >&2
echo " Available versions:" >&2
apt-cache madison docker-ce | cut -f 2 -d \| | sed -r 's/^/ -/g' >&2
echo
echo " 1) You may need to contact your system administrator to upgrade this script." >&2
echo " 2) Meanwhile, if you know what you are doing, you can set yourself a target version" >&2
echo " by setting TARGET_DOCKER_VERSION." >&2
exit 1
install_static_version() {
local docker_version="$1"
local url="$STATIC_DOCKER_URL/docker-${docker_version}.tgz"
local service
## ensure shadowlocal is set up
if ! [ -e /etc/profile.d/shadowlocal.sh ]; then
cat <<EOF > /etc/profile.d/shadowlocal.sh || return 1
## add /opt/merge/bin to PATH if not already there
if [[ ":$PATH:" != *":/opt/merge/bin:"* ]]; then
export PATH="/opt/merge/bin:\$PATH"
fi
EOF
fi
if ! [ -e /etc/systemd/system.conf.d/shadowlocal.sh ]; then
mkdir -p /etc/systemd/system.conf.d
cat <<EOF > /etc/systemd/system.conf.d/shadowlocal.sh || return 1
[Manager]
DefaultEnvironment=PATH=/opt/merge/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
EOF
systemctl daemon-reload
fi
## install in /opt/apps/docker
apt-get install -y --allow-downgrades \
docker-ce="$distrib_available_version" \
docker-ce-cli="$distrib_available_version" </dev/null &&
local base_install=/opt/apps/docker
if [ -d "${base_install}" ]; then
if [ -d "${base_install}".old ]; then
rm -rfv "${base_install}".old || return 1
fi
mv -v "${base_install}"{,.old} || return 1
fi
echo "Fetching $url" >&2
mkdir -p "${base_install}"/bin &&
(
set -o pipefail
curl -sSL "$url" | tar -xz -C "${base_install}"/bin --strip-components=1
) || return 1
for service in docker:dockerd containerd:containerd; do
bin=${service#*:}
service=${service%%:*}
## get the original ExecStart line
if ! orig_exec_start=$(grep -m 1 '^ExecStart=' /lib/systemd/system/${service}.service); then
echo "ERROR: cannot find ExecStart in /lib/systemd/system/${service}.service" >&2
return 1
fi
## override the ExecStart line by changing only the binary
new_exec_start="$(echo "$orig_exec_start" | sed -r 's|ExecStart=[^ ]+|/opt/merge/bin/'"${bin}"'|')"
mkdir -p "${base_install}/etc/systemd/system/${service}.service.d"
mkdir -p "/etc/systemd/system/${service}.service.d"
cat <<EOF > "${base_install}/etc/systemd/system/${service}.service.d/docker-static.conf"
[Service]
ExecStart=
ExecStart=$new_exec_start
EOF
## override systemd config
ln -sf /opt/merge/etc/systemd/system/docker.service.d/docker-static.conf \
/etc/systemd/system/docker.service.d/docker-static.conf
done
## Create symlinks to /opt/merge/bin with /opt/apps/docker/bin/*
shadowlocal add docker || return 1 ## requires kal-scripts
if [ -z "$NO_DOCKER_RESTART" ]; then
systemctl daemon-reload &&
service containerd restart &&
service docker restart
fi
}
uninstall_static_version() {
local base_install=/opt/apps/docker
if [ -d "${base_install}" ]; then
rm -rfv "${base_install}" || return 1
fi
find -L "/opt/merge/bin" -maxdepth 1 -type l -ilname "/opt/apps/docker"/\* -exec echo rm -v {} \; || return 1
for service in docker containerd; do
rm -vf "/etc/systemd/system/${service}.service.d/docker-static.conf" || return 1
done
}
## if currently static and it doesn't need it anymore, uninstall
if [[ "$is_static_docker_install" == 1 ]] && [[ "$need_static" == 0 ]]; then
echo "INFO: uninstalling static docker version" >&2
uninstall_static_version || exit 1
fi
## if current docker-ce debian version is not the target debian version, install it
if [[ "$current_docker_ce_package_version" != "$target_deb_version" ]]; then
echo "INFO: installing docker-ce deb version $target_deb_version" >&2
apt-get install -y --allow-downgrades \
docker-ce="$target_deb_version" </dev/null || exit 1
if [ -z "$NO_DOCKER_RESTART" ]; then
systemctl daemon-reload &&
service containerd restart &&
service docker restart
fi
fi
## if current docker-ce-cli debian version is not the target debian version, install it
if [[ "$current_docker_ce_cli_package_version" != "$target_deb_version" ]]; then
echo "INFO: installing docker-ce-cli deb version $target_deb_version" >&2
apt-get install -y --allow-downgrades \
docker-ce-cli="$target_deb_version" </dev/null || exit 1
fi
## if we need a static version and it is not installed, install it
## and if we need a static version and it is installed but not the target version, install it
if [[ "$need_static" == 1 ]] && [[ "$is_static_docker_install" == 0 || "$target_version" != "$docker_server_version" ]]; then
echo "INFO: installing static docker version $target_version" >&2
install_static_version "$target_version" || exit 1
fi
Write Preview
Loading…
Cancel
Save