Complete script rework.
Some checks failed
continuous-integration/drone/push Build is failing

This commit is contained in:
Stanislav Nikitin 2022-06-28 20:15:13 +05:00
parent 68137b31c1
commit 996c79e4b4
Signed by: pztrn
GPG Key ID: 1E944A0F0568B550
2 changed files with 148 additions and 56 deletions

View File

@ -28,7 +28,8 @@ steps:
privileged: true
environment:
REGISTRY: code.pztrn.name
REGISTRY_USER: drone
REGISTRY_PROJECT: /containers/mirrors
REGISTRY_USERNAME: drone
REGISTRY_PASSWORD:
from_secret: drone_secret
commands:

201
mirror.sh
View File

@ -1,80 +1,171 @@
#!/usr/bin/env bash
# The Docker Image Mirror script.
WHAT_TO_MIRROR=()
DESTINATION_REGISTRY=${REGISTRY}
DESTINATION_PROJECT=${DESTINATION_REGISTRY}/containers/mirror
USER=${REGISTRY_USER}
PASSWORD=${REGISTRY_PASSWORD}
# Designed to mirror amd64 and arm64 images somewhere you want.
# Required environment variables:
#
# * REGISTRY: to which registry images should be sent. Should not contain protocols,
# should be the very same as you use 'docker login' with.
# * REGISTRY_USERNAME: user name to use for destination registry.
# * REGISTRY_PASSWORD: password to use for destination registry's user.
# * REGISTRY_PROJECT: path within registry (or it's part) where images will be push'd.
# Should start with '/'!
function mirror() {
# What images we will mirror. Collected by executing scripts in "images" directory, see
# "collect_images" function.
WHAT_TO_MIRROR=()
# New tag for currently processing image as it will be used with 'docker push'.
# Updates for every image. Contains only path, image name and base tag from source.
REMOTE_IMAGE=""
# Is image multiarch? E.g. is we're successfully fetched not only amd64 image,
# but also an arm64? Updates for every image.
MULTIARCH=0
function cleanup() {
local image=$1
local os_and_arch=$2
docker image rm "${image}" &> /dev/null
docker image rm "${REMOTE_IMAGE}" &> /dev/null
docker image rm "${REMOTE_IMAGE}"-amd64 &> /dev/null
docker image rm "${REMOTE_IMAGE}"-arm64 &> /dev/null
}
function collect_images() {
# Load shell files and execute them to get list of mirrorred images.
MIRROR_CONFIGS=$(ls ./images/*.sh)
# shellcheck disable=SC2068
for file in ${MIRROR_CONFIGS[@]}; do
echo "Importing ${file}..."
# shellcheck disable=SC2086,SC2207,SC2206
WHAT_TO_MIRROR=( ${WHAT_TO_MIRROR[@]} $(bash ${file}) )
done
echo "Images to mirror: ${WHAT_TO_MIRROR[*]}"
}
function get_amd64_image() {
local image=$1
image_name=$(echo "${image}" | cut -d":" -f 1)
image_version=$(echo "${image}" | cut -d":" -f 2)
echo -n "Mirroring ${image} for '${os_and_arch}'... "
echo -ne "\t* Getting amd64 layers... "
# arm64 layers might be missing. So we just put "FAIL!" here and do nothing else.
if ! docker pull --platform=linux/amd64 "${image}" &> /dev/null; then
echo "FAIL!"
if ! docker pull --platform="${os_and_arch}" "${image}" &> /dev/null; then
echo "PULL FAILED"
if [ "${os_and_arch/linux\/amd64//}" != "${os_and_arch}" ] ; then
exit 1
fi
return 1
fi
echo -n "Downloaded, "
image_hash=$(docker images -a | grep "^${image_name}" | grep "${image_version}" | awk {' print $3 '})
if ! docker tag "${image_hash}" "${REMOTE_IMAGE}-amd64" &> /dev/null; then
echo "but tagging failed!"
exit 1
fi
echo "tagged."
}
function get_arm64_image() {
local image=$1
image_name=$(echo "${image}" | cut -d":" -f 1)
image_version=$(echo "${image}" | cut -d":" -f 2)
echo -ne "\t* Getting arm64 layers... "
# arm64 layers might be missing. So we just put "FAIL!" here and do nothing else.
if ! docker pull --platform=linux/arm64 "${image}" &> /dev/null; then
echo "FAIL!"
return
fi
# shellcheck disable=SC1083
echo -n "Downloaded, "
image_hash=$(docker images -a | grep "^${image_name}" | grep "${image_version}" | awk {' print $3 '})
echo -n "${image_hash} for '${os_and_arch}' received, retag as '${DESTINATION_PROJECT}/${image}'... "
if ! docker tag "${image_hash}" "${DESTINATION_PROJECT}/${image}" &> /dev/null; then
echo "TAGGING FAILED"
if ! docker tag "${image_hash}" "${REMOTE_IMAGE}-arm64" &> /dev/null; then
echo "but tagging failed!"
exit 1
fi
echo -n "pushing... "
if ! docker push "${DESTINATION_PROJECT}/${image}" &> /dev/null; then
echo "FAILED"
exit 1
fi
echo "tagged."
echo "OK"
docker image rm "${image}" &> /dev/null
docker image rm "${DESTINATION_PROJECT}/${image}" &> /dev/null
MULTIARCH=1
}
# Starting Docker daemon.
/usr/local/bin/dockerd --data-root=/var/lib/docker &
function login_to_registry() {
# Login to registry.
echo "Logging into '${REGISTRY}' as '${USER}'..."
docker login -u "${USER}" -p "${PASSWORD}" "${REGISTRY}"
}
# Wait for it.
echo "Waiting for Docker daemon to start..."
while true; do
if docker ps &> /dev/null; then
break
function mirror() {
local image=$1
image_name=$(echo "${image}" | cut -d":" -f 1)
image_version=$(echo "${image}" | cut -d":" -f 2)
echo "* Mirroring ${image}"
REMOTE_IMAGE="${REGISTRY}${REGISTRY_PROJECT}/${image}"
MULTIARCH=0
# We presumes that amd64 image should always be available.
if ! get_amd64_image "${image}"; then
echo "! Image mirroring failed! Cannot obtain amd64 image!"
fi
done
# Load shell files and execute them to get list of mirrorred images.
MIRROR_CONFIGS=$(ls ./images/*.sh)
# shellcheck disable=SC2068
for file in ${MIRROR_CONFIGS[@]}; do
echo "Importing ${file}..."
# shellcheck disable=SC2086,SC2207,SC2206
WHAT_TO_MIRROR=( ${WHAT_TO_MIRROR[@]} $(bash ${file}) )
done
echo "Images to mirror: ${WHAT_TO_MIRROR[*]}"
# Login to registry.
echo "Logging into '${DESTINATION_REGISTRY}' as '${USER}'..."
docker login -u "${USER}" -p "${PASSWORD}" "${DESTINATION_REGISTRY}"
# Mirror images.
for image in "${WHAT_TO_MIRROR[@]}"; do
mirror "${image}" linux/amd64
#mirror "${image}" linux/arm64
get_arm64_image "${image}"
push_multiarch_image "${image}"
cleanup "${image}"
}
function push_multiarch_image() {
local image=$1
if ! docker push "${REMOTE_IMAGE}"-amd64; then
echo -e "\t! amd64 image push failed!"
fi
if ! docker push "${REMOTE_IMAGE}"-arm64; then
echo -e "\t! arm64 image push failed!"
fi
if [ ${MULTIARCH} -eq 1 ]; then
echo -e "\t* Image is multi-arch, creating and pushing a manifest..."
docker manifest create "${REMOTE_IMAGE}" \
--amend "${REMOTE_IMAGE}"-amd64 \
--amend "${REMOTE_IMAGE}"-arm64 \
&> /dev/null
docker manifest push "${REMOTE_IMAGE}" &> /dev/null
fi
}
function start_docker_daemon() {
# Starting Docker daemon.
/usr/local/bin/dockerd --data-root=/var/lib/docker &
# Wait for it.
echo "Waiting for Docker daemon to start..."
while true; do
if docker ps &> /dev/null; then
break
fi
done
}
start_docker_daemon
login_to_registry
collect_images
for package in "${WHAT_TO_MIRROR[@]}"; do
mirror "${package}"
done