docker_build

#!/usr/bin/env bash

# set -eux -o pipefail

# the 1st argument of this script expects the name of the environment to build for
source $(pwd)/env/${1}.env

# the 2nd argument of this script expects the full container image URI minus the tag
if [ "${2}" = "" ]
then
  echo "Usage: $0 <runtime.env> <docker_image_uri>"
  exit
fi

export MAIN_PID=$$

export PCAP_RT_ENV="${ENV}"

export BIN_DIR="$(pwd)/bin"
export BASE_IMAGE_DIR="$(pwd)/base-image"
export SUPERVISORD_DIR="$(pwd)/supervisord"
export PCAPFSN_DIR="$(pwd)/pcap-fsnotify"
export TCPDUMPW_DIR="$(pwd)/tcpdumpw"
export GCSFUSE_DIR="$(pwd)/gcsfuse"

export DOCKER_TAG_SUFFIX="libpcap-v${LIBPCAP_VERSION}_tcpdump-v${TCPDUMP_VERSION}"

if [ -d ${BIN_DIR} ]; then
  echo "cleaning release directory: ${BIN_DIR}"
  rm -rvf ${BIN_DIR}/*
else
  echo "creating release directory: ${BIN_DIR}"
  mkdir -p ${BIN_DIR}
fi

function docker_tags {
  local d=' --tag=' f=${1-}
  printf "%s" "$f" "${@/#/$d}"
}

function docker_build_base {
  DOCKER_FILE="${BASE_IMAGE_DIR}/${1}.Dockerfile"

  echo "building: ${DOCKER_FILE}"
  
  docker buildx build --no-cache \
    --file="${DOCKER_FILE}" \
    --build-arg="GOLANG_VERSION=${GOLANG_VERSION}" \
    --build-arg="LIBPCAP_VERSION=${LIBPCAP_VERSION}" \
    --build-arg="TCPDUMP_VERSION=${TCPDUMP_VERSION}" \
    --build-arg="LIBPCAP_URL=${LIBPCAP_URL}" \
    --build-arg="TCPDUMP_URL=${TCPDUMP_URL}" \
    --label="LIBPCAP_VERSION=${LIBPCAP_VERSION}" \
    --label="TCPDUMP_VERSION=${TCPDUMP_VERSION}" \
    --tag="pcap-${1}:${DOCKER_TAG_SUFFIX}" \
    ${BASE_IMAGE_DIR}
  
  if [ $? -ne 0 ]; then
    echo "failed to build: ${DOCKER_FILE}"
    kill -s TERM $MAIN_PID
  fi
}

function docker_build {
  echo "building: ${1}"

  docker buildx build \
    --platform=linux/amd64 \
    --file="${1}/Dockerfile" \
    --build-arg="GOLANG_VERSION=${GOLANG_VERSION}" \
    --build-arg="LIBPCAP_VERSION=${LIBPCAP_VERSION}" \
    --build-arg="TCPDUMP_VERSION=${TCPDUMP_VERSION}" \
    --no-cache --output "${BIN_DIR}" --target releaser .

  if [ $? -ne 0 ]; then
    echo "failed to build: ${1}"
    kill -s TERM $MAIN_PID
  fi
}

function docker_release {
  docker buildx build \
    --no-cache --push \
    --platform=linux/amd64 \
    --file="$(pwd)/Dockerfile" \
    --build-arg="PCAP_RT_ENV=${PCAP_RT_ENV}" \
    --build-arg="GOLANG_VERSION=${GOLANG_VERSION}" \
    --build-arg="LIBPCAP_VERSION=${LIBPCAP_VERSION}" \
    --build-arg="TCPDUMP_VERSION=${TCPDUMP_VERSION}" \
    --label="LIBPCAP_VERSION=${LIBPCAP_VERSION}" \
    --label="TCPDUMP_VERSION=${TCPDUMP_VERSION}" \
    "--tag=$@" $(pwd)
}

echo "Building Cloud Run PCAP sidecar: LIBPCAP-v${LIBPCAP_VERSION} + TCPDUMP-v${TCPDUMP_VERSION}"

docker_build_base base
docker_build_base sidecar
docker_build_base golang

docker_build ${SUPERVISORD_DIR}
docker_build ${PCAPFSN_DIR}
docker_build ${TCPDUMPW_DIR}

# patch GCSFuse for Cloud Run gen1
if [[ "$PCAP_RT_ENV" == "cloud_run_gen1" ]]; then
  docker_build ${GCSFUSE_DIR}
fi

# Fully Qualified Docker Image Name
FQDIN="${2}:${DOCKER_TAG_SUFFIX}"

# build `tcpdump` sidecar image
if [[ -z "${3}" ]]; then
  # flow for manual builds: if no 3rd arg (v#.#.#) is provided
  echo "Creating images: '${2}:${IMAGE_TAG}' and '${FQDIN}'"
  docker_release `docker_tags "${2}:${IMAGE_TAG}" "${FQDIN}"`
elif [[ "${3}" == *"-RC" ]]; then
  # flow for release candidates: 3rd arg / tag contains "RC", so do not push to newest/latest
  echo "Creating release candidate (RC) images: '${2}:${3}-${GEN}' and '${FQDIN}'"
  docker_release `docker_tags "${2}:${3}-${GEN}" "${FQDIN}"`
else
  # flow for non RC version: if a 3rd arg (v#.#.#) without RC is provided then apply both tags
  echo "Releasing images: '${2}:${IMAGE_TAG}', '${2}:${3}-${GEN}' and '${FQDIN}'"
  docker_release `docker_tags "${2}:${3}-${GEN}" "${2}:${IMAGE_TAG}" "${FQDIN}"`
fi