starlingx/tools
Code Issues Proposed changes
b9e695f8f7
tools/stx-init-env
Davlet Panech 44ccc58f55 stx-init-env: get LAT installer from $STX_MIRROR 
LAT docker file downloads the installer from a hard-coded URL that
points to https://mirror.starlingx.windriver.com . Allow users to
override this location by defining STX_MIRROR_URL in the host
environment. By default, guess mirror location from stx.conf.

TESTS
==========================
* Rebuild LAT container and make sure it uses the mirror URL from
  stx.conf
* Set STX_MIRROR_URL prior to calling stx-init-env and make sure it
  gets picked up by the docker file

Story: 2010055
Task: 49883

Signed-off-by: Davlet Panech <davlet.panech@windriver.com>
Change-Id: Id8ea88407f74003db934337efd574451658633d8
2024-04-17 16:23:05 +00:00

766 lines
24 KiB
Bash
Executable File
Raw Blame History

#!/bin/bash
if [[ "$0" != "${BASH_SOURCE[0]}" ]] ; then
echo >&2 "Don't source this file, execute it instead, eg: ${BASH_SOURCE[0]} --help"
return 1
fi
usage() {
cat <<END
Usage: $0 OPTIONS
Initialize StarlingX build environment & (re-)start builder pods
-R,--restart-minikube
restart minikube profile before starting pods
--rebuild[=IMG,...]
build specified pod images instead of downloading them
--cache when rebuilding, allow docker to use its filesystem cache
when pulling, skip images that already exist locally
CAUTION: this option may not pick up all the changes to
docker source files and is meant for debugging
the build scripts.
--dockerhub-login
execute "docker login" prior to building or pulling builder
images
--no-start Refresh builder images, but don't (re-)start pods
ENVIRONMENT RESET OPTIONS
=========================
-y,--assumeyes
Assume "yes" for all questions
-D,--delete-minikube-profile
Delete minikube profile and exit
This will also delete any builder images.
Following this command you have to re-run this script
(possibly with --rebuild).
--nuke DEPRECATED: same as --delete-minikube-profile
--reset delete chroots and restart the environment
--reset-hard Delete env containers, minikube profile and all generated
content, including the workspace directory, compiled DEBs,
ISO, OSTree, chroots, aptly repositories, docker FS layers
and build logs.
Keep the "downloads" directory and stx.conf.
Following this action you must re-run this script
(possibly with --rebuild) to start minikube and the pods
again, followed by 'downloader', 'build-pkgs' etc.
END
}
source "$(dirname "$0")"/import-stx || exit 1
PROGNAME=$(basename "$0") || exit 1
STX_TOOLS_DIR="$(readlink -v -e "$(dirname "$0")")" || exit 1
MINIKUBE=minikube
HELM=helm
DOCKER=docker
PYTHON3=python3
KUBECTL=kubectl
DOCKER_PREFIX=${STX_PREBUILT_BUILDER_IMAGE_PREFIX:-'starlingx/'}
DOCKER_IMAGES="stx-builder stx-pkgbuilder stx-lat-tool stx-aptly"
DOCKER_TAG="$STX_PREBUILT_BUILDER_IMAGE_TAG"
DOCKERHUB_LOGIN=0
BUILD_DOCKER=0
DELETE_MINIKUBE_PROFILE=0
RESTART_MINIKUBE=0
CLEAN_CONFIG=0
USE_DOCKER_CACHE=0
START_PODS=1
RESET_SOFT=0
RESET_HARD=0
ASSUME_YES=0
COREUTILS_DOCKER_IMAGE="debian:bookworm-20240130-slim"
info() {
local tty_on tty_off
if [[ -t 2 ]] ; then
tty_on=$'\033[0;36m'
tty_off=$'\033[0m'
fi
echo >&2 "${tty_on}$*${tty_off}"
}
notice() {
local tty_on tty_off
if [[ -t 2 ]] ; then
tty_on=$'\033[1;36m'
tty_off=$'\033[0m'
fi
echo >&2 "${tty_on}$*${tty_off}"
}
warn() {
local tty_on tty_off
if [[ -t 2 ]] ; then
tty_on=$'\033[33m'
tty_off=$'\033[0m'
fi
echo >&2 "${tty_on}WARNING: $*${tty_off}"
}
error() {
local tty_on tty_off
if [[ -t 2 ]] ; then
tty_on=$'\033[31m'
tty_off=$'\033[0m'
fi
echo >&2 "${tty_on}ERROR: $*${tty_off}"
}
die() {
error "$@"
exit 1
}
# Usage: confirm "ACTION DESCRIPTION"
confirm() {
local continue_yn="Continue (yes/no)? "
if [[ "$ASSUME_YES" -eq 1 ]] ; then
echo "$1"
echo "${continue_yn}yes"
return 0
fi
if [[ ! -t 0 ]] ; then
echo "$1"
die "Won't read from non-terminal"
fi
local answer
echo "$1"
while true ; do
read -e -r -p "$continue_yn" answer || exit 1
if [[ "$answer" == "yes" ]] ; then
return 0
elif [[ "$answer" == "no" ]] ; then
return 1
else
echo >&2 "Please type \`yes' or \`no'"
echo >&2
fi
done
}
# Usage: regex_quote "STR"
regex_quote() {
echo "$1" | sed -r 's/([$.(){}+*^[\])/\\\1/g'
}
# Usage: regex_match "STR" "PYTHON_STYLE_REGEX"...
regex_match() {
local str="$1" ; shift || :
python3 -c "\
import re,sys;
str = sys.argv[1]
exprlist = sys.argv[2:]
for expr in exprlist:
#print (\"========= [%s] [%s]\" % (str, expr))
if re.match(expr, str):
sys.exit(0)
sys.exit(1)
" "$str" "$@"
}
# Usage: starts_with "STR" "PREFIX"
starts_with() {
local str="$1"
local prefix="$2"
if [[ "${str#$prefix}" == "$str" ]] ; then
return 1
fi
return 0
}
minikube_profile_is_started() {
minikube status -p "$MINIKUBENAME" >/dev/null 2>&1
}
minikube_profile_exists() {
local script=$(cat <<'END'
import json,sys
data = json.load (sys.stdin)
if 'valid' not in data or 'invalid' not in data:
sys.exit(1)
for x in data['valid']+data['invalid']:
if x['Name'] == sys.argv[1]:
sys.exit(0)
sys.exit(1)
END
)
$MINIKUBE profile list -l -o json | $PYTHON3 -c "$script" "$MINIKUBENAME"
}
minikube_profile_start() {
notice "Starting minikube profile \`$MINIKUBENAME'"
$MINIKUBE start --driver=docker -p $MINIKUBENAME \
--cpus=$STX_BUILD_CPUS \
--memory=$MINIKUBEMEMORY \
--mount=true \
--mount-string="$STX_BUILD_HOME:/workspace" \
|| exit 1
}
minikube_profile_stop() {
if minikube_profile_is_started ; then
notice "Stopping minikube profile \`$MINIKUBENAME'"
$MINIKUBE stop -p $MINIKUBENAME
if minikube_profile_is_started ; then
echo >&2 "minikube container $MINIKUBENAME exist!"
echo >&2 "And the command 'minikube -p $MINIKUBENAME stop' failed. The reason may be"
echo >&2 "the current MINIKUBE_HOME/HOME is not the same as the $MINIKUBENAME"
echo >&2 "Please change the MINIKUBE_HOME/HOME directory to the previous value"
echo >&2 "then re-execute this script"
exit 1
fi
fi
}
stx_is_started() {
stx control is-started >/dev/null 2>&1
}
stx_stop() {
stx control stop --wait || exit 1
}
stx_start() {
stx config --upgrade || exit 1
stx control start --wait || exit 1
}
#
# Blacklist for root-owned deletions.
# A multi-line string, one Python regex per line, leading/trailing
# spaces and comments will be stripped.
#
if [[ -z "$STX_RM_BLACKLIST" ]] ; then
USER_REGEX="$(regex_quote "$USER")" || exit 1
HOME_REGEX="$(regex_quote "$HOME")" || exit 1
STX_RM_BLACKLIST='
^/$
^/bin(/.*)?$
^/boot(/.*)?$
^/dev(/.*)?$
^/etc(/.*)?$
^/export(/.*)?$
^/home$ # deny "/home"
^/home/'"$USER_REGEX"'$ # deny "/home/$USER"
^/home/(?!'"$USER_REGEX"'(/.*)?$) # deny "/home/SOME_USER_OTHER_THAN_CURRENT"
^'"$HOME_REGEX"'$
^/import(/.*)?$
^/localdisk$
^/localdisk/designer$
^/localdisk/designer/'"$USER_REGEX"'$
^/localdisk/designer/(?!'"$USER_REGEX"'(/.*)?$)
^/localdisk/loadbuild$
^/localdisk/loadbuild/'"$USER_REGEX"'$
^/localdisk/loadbuild/(?!'"$USER_REGEX"'(/.*)?$)
^/folk(/.*)?$
^/lib[^/]*(/.*)?$
^/media(/.*)?$
^/mnt(/.*)?$
^/opt(/.*)?$
^/proc(/.*)?$
^/root(/.*)?$
^/run(/.*)?$
^/sbin(/.*)?$
^/snap(/.*)?$
^/srv(/.*)?$
^/starlingx(/.*)?$
^/sys(/.*)?$
^/tmp(/.*)?$
^/usr(/.*)?$
^/var(/.*)?$
'
fi
# Usage: safe_rm PATHs...
#
# Delete PATHs as root user, by default via "sudo"; or else
# via "docker run [...]". Bail out on blacklisted paths.
#
safe_rm() {
local build_home
build_home="$(readlink -v -e "$STX_BUILD_HOME")" || exit 1
local build_home_quoted
build_home_quoted="$(regex_quote "$build_home")"
# Compile blacklist from $STX_RM_BLACKLIST + current $STX_BUILD_HOME
local -a re_list
readarray -t re_list < <(echo "$STX_RM_BLACKLIST" | sed -r -e 's/\s#.*//g' -e 's/^\s+//' -e 's/\s+$//' -e '/^\s*$/d') || exit 1
re_list+=("^$build_home_quoted$")
# Validate inputs
local -a paths_to_delete
local path basename dirname
local canon_dirname canon_path canon_path_expr
for path in "$@" ; do
# Resolve paths before checking against blacklist. We want to resolve
# them similarly to how "rm -rf" would, ie:
#
# - recursively resolve symlinks leading up to the leaf (basename) of
# the target path
# - do not resolve the leaf; if it happens to be a symlink, just delete
# the symlink
#
# special case 1: never remove anything that ends with "." or ".."
#
# special case 2: if path ends with a slash, the leaf must exist and be a
# directory or a symlink to one; otherwise we skip it:
# - real dir: remove recursively
# - symlink to a dir: remove target's children only
# - anything else: skip
#
# don't remove "." or ".."
if [[ "$path" =~ (^|/)[.][.]?$ ]] ; then
error "refusing to remove \".\" or \"..\" directory"
exit 1
fi
# path doesn't end with "/": resolve parents, but not the leaf
if [[ ! "$path" =~ /$ ]] ; then
basename="$(basename "$path")"
[[ -n "$basename" ]] || continue
dirname="$(dirname "$path")"
[[ -n "$dirname" ]] || continue
canon_dirname="$(realpath -q -e "$dirname" || true)"
[[ -n "$canon_dirname" ]] || continue
canon_path="$canon_dirname/$basename"
# ie path exists or is a broken symlink
[[ -e "$canon_path" || -L "$canon_path" ]] || continue
canon_path_expr="$canon_path" # argument to "rm"
# path ends with "/": only makes sense for dirs or symlinks to dirs
else
# Try to resolve the entire path, including the leaf.
# If leaf is a legit symlink, "rm" would follow it, so we do the same
canon_path="$(realpath -q -m "$path" || true)"
[[ -d "$canon_path" ]] || continue
canon_path_expr="$canon_path/" # argument to "rm" must preserve trailing /
fi
# Make sure it's a subdirectory of $STX_BUILD_HOME
if ! starts_with "$canon_path" "$build_home/" ; then
error "Attempted to delete unsafe path \`$canon_path', expecting a subdirectory of \`$STX_BUILD_HOME'"
exit 1
fi
# Check it against black list
if regex_match "$canon_path" "${re_list[@]}" ; then
die "Attempted to delete blacklisted path \`$canon_path'"
fi
# ok to delete
paths_to_delete+=("$canon_path_expr")
done
# Delete them
local -a rm_cmd
for path in "${paths_to_delete[@]}" ; do
#confirm "Deleting \`$path'"$'' || continue
# Delete via docker or sudo
if [[ "$STX_RM_METHOD" == "docker" ]] ; then
local tty_opt=
if [[ -t 0 ]] ; then
tty_opt="-t"
fi
rm_cmd=(docker run -i $tty_opt --rm --mount "type=bind,src=$build_home,dst=$build_home" $COREUTILS_DOCKER_IMAGE rm -rf --one-file-system "$path")
else
rm_cmd=(sudo rm -rf --one-file-system "$path")
fi
echo "running: ${rm_cmd[*]}" >&2
"${rm_cmd[@]}" || exit 1
done
}
init_stx_mirror_url() {
if [[ -z "$STX_MIRROR_URL" && -f "$STX_TOOLS_DIR/stx.conf" ]] ; then
STX_MIRROR_URL=$(sed -n -r 's/^\s*stx_mirror_url\s*=\s*//gp' "$STX_TOOLS_DIR/stx.conf" | sed "s/[\"']//g")
fi
}
cmdline_error() {
if [[ -n "$1" ]] ; then
echo "error: $1" >&2
fi
echo "Type \`$0 --help' for more info." >&2
exit 1
}
# process command line
temp=$(getopt -o hRyD --long help,clean,restart-minikube,rebuild::,cache,delete-minikube-profile,nuke,reset,reset-hard,assumeyes,dockerhub-login,no-start -n "$PROGNAME" -- "$@") || cmdline_error
eval set -- "$temp"
while true ; do
case "$1" in
-h|--help)
usage
exit 0
;;
-R|--restart-minikube)
RESTART_MINIKUBE=1
shift
;;
--clean)
CLEAN_CONFIG=1
shift
;;
--rebuild)
if [[ -n "$2" ]] ; then
for img in $(echo "$2" | sed 's/,,*/ /g') ; do
img_ok=no
for known_img in $DOCKER_IMAGES ; do
if [[ "$img" == "$known_img" || "stx-$img" == "$known_img" ]] ; then
BUILD_DOCKER_IMAGES+="$known_img "
img_ok=yes
break
fi
done
if [[ $img_ok != yes ]] ; then
cmdline_error "invalid image \"$img\""
fi
done
else
BUILD_DOCKER_IMAGES="$DOCKER_IMAGES"
fi
shift 2
;;
--cache)
USE_DOCKER_CACHE=1
shift
;;
-y|--assumeyes)
ASSUME_YES=1
shift
;;
--nuke)
warn "--nuke is deprecated, use --delete-minikube-profile instead"
DELETE_MINIKUBE_PROFILE=1
shift
;;
-D|--delete-minikube-profile)
DELETE_MINIKUBE_PROFILE=1
shift
;;
--reset)
RESET_SOFT=1
shift
;;
--reset-hard)
RESET_HARD=1
shift
;;
--dockerhub-login)
DOCKERHUB_LOGIN=1
shift
;;
--no-start)
START_PODS=0
shift
;;
--)
shift
break
;;
-?*)
cmdline_error
;;
*)
break
;;
esac
done
[[ "$#" -le 0 ]] || cmdline_error "too many arguments"
# make sure required programs are installed
if [ "$STX_PLATFORM" = "minikube" ]; then
if ! command -v "$MINIKUBE" &> /dev/null; then
echo >&2 "Command $MINIKUBE could not be found."
echo >&2 "Please install it as https://minikube.sigs.k8s.io/docs/start/"
echo ""
exit 1
fi
fi
if [ "$STX_PLATFORM" = "kubernetes" ]; then
if ! command -v "$KUBECTL" &> /dev/null; then
echo >&2 "Command $KUBECTL could not be found."
echo >&2 "Please install and configure kubectl."
echo ""
exit 1
fi
fi
if ! command -v "$HELM" &> /dev/null; then
echo >&2 "Command $HELM could not be found."
echo >&2 "Please install it as https://helm.sh/"
echo ""
exit 1
fi
if ! command -v "$DOCKER" &> /dev/null; then
echo >&2 "Command $DOCKER could not be found. Please install it."
echo >&2 ""
exit 1
fi
# Delete minikube profile/cluster. This will also delete the locally-built
# or downloaded builder pods.
if [[ $DELETE_MINIKUBE_PROFILE -eq 1 ]] ; then
if [[ "$STX_PLATFORM" != "minikube" ]] ; then
notice "--delete-minikube-profile is not supported for Kubernetes platform"
elif minikube_profile_exists ; then
notice "Deleting minikube profile \`$MINIKUBENAME'"
$MINIKUBE delete -p "$MINIKUBENAME" || exit 1
else
notice "Please check your minikube profile MINIKUBENAME: \`$MINIKUBENAME'."
notice "It doesn't exist or it existed but not for your MINIKUBE_HOME: \`$MINIKUBE_HOME'."
notice "Please re-export the correct project variable pairs!!!"
fi
exit 0
fi
# clean the configuration and configmap data
if [[ $CLEAN_CONFIG -eq 1 ]] ; then
if stx_is_started ; then
notice "Please firstly stop the helm project with 'stx control stop' command."
notice "Then execute this cleanup operation again."
exit 1
fi
notice "Clean the config file and configmap data for builder|pkgbuilder container."
# copy a fresh config file
rm -f "$STX_TOOLS_DIR/stx.conf"
cp "$STX_TOOLS_DIR/stx.conf.sample" "$STX_TOOLS_DIR/stx.conf"
rm -f "$STX_TOOLS_DIR"/stx/lib/stx/__pycache__/*
rm -f "$STX_TOOLS_DIR"/stx/stx-build-tools-chart/stx-builder/Chart.lock
rm -f "$STX_TOOLS_DIR"/stx/stx-build-tools-chart/stx-builder/charts/*
rm -f "$STX_TOOLS_DIR"/stx/stx-build-tools-chart/stx-builder/configmap/stx-localrc
rm -f "$STX_TOOLS_DIR"/stx/stx-build-tools-chart/stx-builder/dependency_chart/stx-pkgbuilder/configmap/stx-localrc
exit 0
fi
# --reset-hard: stop pods, delete pod state and minikube profile
if [[ $RESET_HARD -eq 1 ]] ; then
# "stx" tool can't work without stx.conf
if [[ ! -f "$STX_TOOLS_DIR/stx.conf" ]] ; then
error "$STX_TOOLS_DIR/stx.conf: file not found"
exit 1
fi
confirm "\
This will delete env containers, minikube profile and all generated
content, including the workspace directory, generated DEBs, ISO,
OSTree, chroots, aptly repositories, docker FS layers and build logs.
Keep the 'downloads' directory and stx.conf.
Following this action you must re-run this script (possibly with
--rebuild) to start minikube and the pods again, followed by
'downloader', 'build-pkgs' etc.
" || exit 1
# Deleting minikube profile also deletes env pods within it
if [[ "$STX_PLATFORM" = "minikube" ]] ; then
if minikube_profile_exists ; then
notice "Deleting minikube profile \`$MINIKUBENAME'"
$MINIKUBE delete -p "$MINIKUBENAME" || exit 1
fi
else
# stop & delete env pods
if stx_is_started ; then
info "stopping env pods"
stx_stop || exit 1
fi
fi
notice "deleting generated files"
safe_rm "$STX_BUILD_HOME/localdisk/pkgbuilder" \
"$STX_BUILD_HOME/docker" \
"$STX_BUILD_HOME/aptly" \
"$STX_BUILD_HOME/localdisk/loadbuild"/*/*/* \
"$STX_BUILD_HOME/localdisk"/*.log \
"$STX_BUILD_HOME/localdisk"/*.yaml \
"$STX_BUILD_HOME/localdisk"/log \
"$STX_BUILD_HOME/localdisk"/CERTS \
"$STX_BUILD_HOME/localdisk"/channel \
"$STX_BUILD_HOME/localdisk"/deploy \
"$STX_BUILD_HOME/localdisk"/workdir \
"$STX_BUILD_HOME/localdisk"/sub_workdir \
|| exit 1
notice "please use \`$0' to start the environment again"
exit 0
fi
# --reset: delete chroots + restart pods
if [[ $RESET_SOFT -eq 1 ]] ; then
# "stx" tool can't work without stx.conf
if [[ ! -f "$STX_TOOLS_DIR/stx.conf" ]] ; then
error "$STX_TOOLS_DIR/stx.conf: file not found"
exit 1
fi
# Caveat: we have to have minikube started in order to re-start
# env pods (below), otherwise the old/dormant instances
# of the pods may get re-activated later when the user starts
# minikube manually. In this case those may be outdated due
# to changes in stx.conf.
if [[ "$STX_PLATFORM" = "minikube" ]] && ! minikube_profile_is_started ; then
error "minikube profile \`$MINIKUBENAME' is not running, please start it first"
exit 1
fi
# stop env pods
want_stx_start=0
if stx_is_started ; then
want_stx_start=1
notice "stopping env pods"
stx_stop || exit 1
fi
# clean up
notice "deleting chroots"
safe_rm "$STX_BUILD_HOME/localdisk/pkgbuilder"
# start the pods again
if [[ $want_stx_start -eq 1 ]] ; then
notice "starting env pods"
stx_start || exit 1
fi
exit 0
fi
# Make sure $STX_BUILD_HOME exists
if [[ ! -d "$STX_BUILD_HOME" ]] ; then
echo >&2 "The directory $STX_BUILD_HOME doesn't exist, please create it with the command:"
echo >&2 ""
echo >&2 " mkdir -p $STX_BUILD_HOME"
echo >&2 ""
echo >&2 "Then execute this script again!"
exit 1
fi
# Make sure mirror directory exists. If this directory doesn't exist,
# it will be automatically created with root permission.
if [[ ! -d "$STX_BUILD_HOME/mirrors/starlingx" ]] ; then
mkdir -p $STX_BUILD_HOME/mirrors/starlingx || exit 1
fi
# Login to docker hub if necessary
if [[ "$DOCKERHUB_LOGIN" -eq 1 ]] ; then
# This will save docker hub credentials in $HOME/.docker/config.json. If docker hub
# credentials in that file are missing or invalid, this will ask for the username
# and password on the current TTY and save them in the json file. If credentials
# are already in the file, it will reuse them. In any case this will instruct
# host's docker daemon to obtain an authentication token for all subsequent
# interactions with docker hub.
info "authenticating host docker daemon with docker hub"
docker login || exit 1
fi
if [ "$STX_PLATFORM" = "minikube" ]; then
# Stop minikube if necessary
WANT_START_MINIKUBE=0
if [[ $RESTART_MINIKUBE -eq 1 ]] ; then
minikube_profile_stop
WANT_START_MINIKUBE=1
elif ! minikube_profile_is_started ; then
WANT_START_MINIKUBE=1
fi
# Start minikube
if [[ $WANT_START_MINIKUBE -eq 1 ]] ; then
minikube_profile_start
fi
# Record the project environment variables
echo "The last minikube profile startup date: `date`" > "$STX_TOOLS_DIR"/minikube_history.log
echo "MINIKUBE_HOME: $MINIKUBE_HOME" >> "$STX_TOOLS_DIR"/minikube_history.log
echo "MINIKUBENAME: $MINIKUBENAME" >> "$STX_TOOLS_DIR"/minikube_history.log
echo "STX_BUILD_HOME: $STX_BUILD_HOME" >> "$STX_TOOLS_DIR"/minikube_history.log
# Import minikube's docker environment. This points docker CLI to minikube's
# embedded docker daemon.
eval $(minikube -p $MINIKUBENAME docker-env)
# Ask minikube's docker daemon to obtain docker hub's access token
if [[ "$DOCKERHUB_LOGIN" -eq 1 ]] ; then
info "authenticating minikube's docker daemon with docker hub"
docker login || exit 1
fi
elif [[ $RESTART_MINIKUBE -eq 1 ]] ; then
warn "--restart-minikube is only supported on minikube platform -- ignoring"
fi
if [[ -n "${BUILD_DOCKER_IMAGES}" ]] ; then
notice "Building docker images"
declare -a docker_build_args
if [[ "$USE_DOCKER_CACHE" != "1" ]] ; then
docker_build_args+=("--no-cache")
fi
for img in $BUILD_DOCKER_IMAGES; do
extra_build_args=()
if grep -q -E '^\s*ARG\s+STX_MIRROR_URL\s*=' "$STX_TOOLS_DIR/"stx/dockerfiles/$img.Dockerfile ; then
init_stx_mirror_url
if [[ -n "$STX_MIRROR_URL" ]] ; then
extra_build_args+=("--build-arg" "STX_MIRROR_URL=$STX_MIRROR_URL")
fi
fi
docker build "${docker_build_args[@]}" "${extra_build_args[@]}" -t $img:$DOCKER_TAG_LOCAL -f "$STX_TOOLS_DIR/"stx/dockerfiles/$img.Dockerfile "$STX_TOOLS_DIR" || exit 1
info "built image $img:$DOCKER_TAG_LOCAL"
done
fi
# Pull images that we didn't rebuild
PULL_DOCKER_IMAGES=$(
for img in ${DOCKER_IMAGES} ; do
built=no
for build_img in ${BUILD_DOCKER_IMAGES} ; do
if [[ "$img" == "$build_img" ]] ; then
built=yes
break
fi
done
if [[ "$built" != "yes" ]] && \
{ [[ "$USE_DOCKER_CACHE" != 1 ]] || ! docker image inspect ${img}:${DOCKER_TAG_LOCAL} >/dev/null 2>&1 ; } ; then
echo "$img"
fi
done
)
if [[ -n "$PULL_DOCKER_IMAGES" ]] ; then
notice "Pulling docker images: "$PULL_DOCKER_IMAGES
for img in $PULL_DOCKER_IMAGES; do
docker pull ${DOCKER_PREFIX}${img}:${DOCKER_TAG} || exit 1
docker tag ${DOCKER_PREFIX}${img}:${DOCKER_TAG} ${img}:${DOCKER_TAG_LOCAL} || exit 1
info "created image ${img}:${DOCKER_TAG_LOCAL} from pre-built ${DOCKER_PREFIX}${img}:${DOCKER_TAG}"
done
fi
# Restart pods
if [[ $START_PODS -eq 1 ]] ; then
if stx_is_started ; then
stx_stop || exit 1
fi
notice "starting env pods"
stx_start || exit 1
fi
View Git Blame Copy Permalink