libcheckout

function checkout() {
  local use_cache=${1:-""}
  if [ -z "${SEMAPHORE_GIT_BRANCH}" ] || [ -z "${SEMAPHORE_GIT_URL}" ] || [ -z "${SEMAPHORE_GIT_DIR}" ] || [ -z "${SEMAPHORE_GIT_SHA}" ]; then
    checkout::validation_message
    return 1
  fi

  rm -rf "$SEMAPHORE_GIT_DIR"

  if [ "$use_cache" = "--use-cache" ]; then
    echo "[Experimental stability] Using cached Git repository."
    checkout::use_cache
  else
    if [ -n "${SEMAPHORE_GIT_REF_TYPE:-}" ]; then
      checkout::refbased
    else
      checkout::shallow
    fi

    exit_code=$?
    if [ "$exit_code" -ne "0" ]; then
      checkout::metric 0
    fi

    return $exit_code
  fi
}

function checkout::validation_message() {
  echo "[CHECKOUT ERROR] Some of these variables are unset:"
  echo "SEMAPHORE_GIT_URL=$SEMAPHORE_GIT_URL"
  echo "SEMAPHORE_GIT_DIR=$SEMAPHORE_GIT_DIR"
  echo "SEMAPHORE_GIT_BRANCH=$SEMAPHORE_GIT_BRANCH"
  echo "SEMAPHORE_GIT_SHA=$SEMAPHORE_GIT_SHA"
}

function checkout::use_cache() {
  export CACHE_FAIL_ON_ERROR="true"

  if ! cache restore git-cache-; then
    echo "Failed to restore from the cache"
    rm -rf "${SEMAPHORE_GIT_DIR}"
  fi

  if [ -d "$HOME/$SEMAPHORE_GIT_DIR" ]; then
    checkout::fetch
  else
    checkout::clone
  fi

  # SC2181: checking the last command's exit code
  # with $? simplifies the control flow of this function.
  # shellcheck disable=SC2181
  if [ "$?" -eq "0" ]; then
    checkout::cache_store
  else
    return 1
  fi
}

function checkout::fetch() {
  echo "Restored cache"
  cd "${HOME}/${SEMAPHORE_GIT_DIR}" || exit
  git remote prune origin
  retry git fetch --tags origin

  checkout::switch_revision
}

function checkout::clone() {
  retry git clone "${SEMAPHORE_GIT_URL}" "${SEMAPHORE_GIT_DIR}"
  cd "${SEMAPHORE_GIT_DIR}" || exit

  checkout::switch_revision
}

function checkout::reset_to_sha {
  if checkout::checkrevision; then
    git reset --hard "${SEMAPHORE_GIT_SHA}" 2>/dev/null
    checkout::metric "$(du -s . | awk '{ print $1 }')"
    return 0
  else
    return 1
  fi
}

function checkout::switch_revision() {
  if [ "${SEMAPHORE_GIT_REF_TYPE:-""}" = "pull-request" ]; then
    if ! retry git fetch origin +"${SEMAPHORE_GIT_REF}": 2>/dev/null; then
      echo "Reference: ${SEMAPHORE_GIT_REF} not found .... Exiting"

      return 1
    else
      checkout::reset_to_sha
    fi

  elif [ "${SEMAPHORE_GIT_REF_TYPE:-''}" = "tag" ]; then
    if ! git checkout -qf "${SEMAPHORE_GIT_TAG_NAME}"; then
      echo "Release $SEMAPHORE_GIT_TAG_NAME not found .... Exiting"

      return 1
    else
      checkout::metric "$(du -s . | awk '{ print $1 }')"
      echo "HEAD is now at ${SEMAPHORE_GIT_SHA} Release ${SEMAPHORE_GIT_TAG_NAME}"

      return 0
    fi

  else
    local branch_origin="origin/$SEMAPHORE_GIT_BRANCH"

    if [[ -n $(git show-ref "${SEMAPHORE_GIT_REF}") ]]; then
      git checkout "${SEMAPHORE_GIT_BRANCH}"
    else
      git checkout -b "${SEMAPHORE_GIT_BRANCH}" -t "${branch_origin}";
    fi

    checkout::reset_to_sha
  fi
}

function checkout::cache_store() {
  # update cache if older then 72h -> 25920s
  SEMAPHORE_GIT_CACHE_AGE="${SEMAPHORE_GIT_CACHE_AGE:-259200}"

  local cache_key
  local cache_age
  cache_key="$(cache list 2>&1 | grep git-cache- || true )"
  if [[ -n "$cache_key" ]];then 
    cache_key=$(echo "${cache_key}" | awk '{ print $1 }'| head -1)
  fi
  cache_age=$(echo "${cache_key}" | cut -d'-' -f8)

  if [[ -n "$cache_age" ]] && [[ $cache_age =~ ^[0-9]+$ ]]; then
    local diff=$(($(date +%s) - cache_age))
    echo "diff: $diff"

    if (( diff > SEMAPHORE_GIT_CACHE_AGE )); then
      echo "Git cache outdated, refreshing..."
      cd ..
      checkout::cleanupcache
      cache store "git-cache-$SEMAPHORE_JOB_ID-$(date +%s)" "${SEMAPHORE_GIT_DIR}"
      cd "${SEMAPHORE_GIT_DIR}" || exit
    else
      echo "Git cache up-to-data."
    fi

  else
    echo "No git cache... caching"
    cd ..
    cache store "git-cache-${SEMAPHORE_JOB_ID}-$(date +%s)" "${SEMAPHORE_GIT_DIR}"
    cd "${SEMAPHORE_GIT_DIR}" || exit
  fi
}

function checkout::cleanupcache {
  if [ -z "${SEMAPHORE_GIT_CACHE_KEEP:-""}" ]; then
    SEMAPHORE_GIT_CACHE_KEEP=0
  fi
  local k=$SEMAPHORE_GIT_CACHE_KEEP

  local list=()
  while IFS='' read -r line; do list+=("$line"); done < <(cache list 2>&1 | grep git-cache- | awk '{ print $1 }')

  for i in "${list[@]:$k}"; do
    cache delete "${i}"
  done

}

function checkout::checkrevision {
  if ! git rev-list HEAD.."${SEMAPHORE_GIT_SHA}" 2>/dev/null; then
    echo "Revision: ${SEMAPHORE_GIT_SHA} not found .... Exiting"
    return 1
  fi
}

function checkout::branch_checkout {
  if ! git checkout -f "$SEMAPHORE_GIT_BRANCH"; then
    echo "Branch: ${SEMAPHORE_GIT_BRANCH} not found .... Exiting"
    return 1
  fi
}

function checkout::shallow() {
  if [ -z "${SEMAPHORE_GIT_DEPTH:-""}" ]; then
    SEMAPHORE_GIT_DEPTH=50
  fi
  echo "Performing shallow clone with depth: $SEMAPHORE_GIT_DEPTH"

  if ! retry git clone --depth "${SEMAPHORE_GIT_DEPTH}" -b "${SEMAPHORE_GIT_BRANCH}" "${SEMAPHORE_GIT_URL}" "${SEMAPHORE_GIT_DIR}"; then
    echo "Branch not found performing full clone"
    retry git clone "${SEMAPHORE_GIT_URL}" "${SEMAPHORE_GIT_DIR}"
    cd "$SEMAPHORE_GIT_DIR" || exit

    if ! checkout::branch_checkout; then
      return 1
    fi

    if checkout::checkrevision; then
      git reset --hard "${SEMAPHORE_GIT_SHA}" 2>/dev/null
    else
      return 1
    fi
  else
    cd "${SEMAPHORE_GIT_DIR}" || exit

    if ! git reset --hard "${SEMAPHORE_GIT_SHA}" 2>/dev/null; then
      echo "SHA: $SEMAPHORE_GIT_SHA not found performing full clone"
      retry git fetch --unshallow

      if checkout::checkrevision; then
        git reset --hard "${SEMAPHORE_GIT_SHA}" 2>/dev/null
      else
        return 1
      fi
    fi
  fi

  checkout::metric "$(du -s . | awk '{ print $1 }')"
}

function checkout::refbased() {
  if [ -z "${SEMAPHORE_GIT_DEPTH:-""}" ]; then
    SEMAPHORE_GIT_DEPTH=50
  fi

  if [ "${SEMAPHORE_GIT_REF_TYPE:-""}" = "pull-request" ]; then
    retry git clone --depth "${SEMAPHORE_GIT_DEPTH}" "${SEMAPHORE_GIT_URL}" "${SEMAPHORE_GIT_DIR}"
    cd "${SEMAPHORE_GIT_DIR}" || exit

    # Try fetching refs/objects with a depth.
    if retry git fetch --depth "${SEMAPHORE_GIT_DEPTH}" origin +"${SEMAPHORE_GIT_REF}": 2>/dev/null; then
      git checkout -qf FETCH_HEAD
      echo "HEAD is now at ${SEMAPHORE_GIT_SHA}"

      return 0
    fi

    # Fetch with depth failed, fallback to not using a depth.
    if retry git fetch origin +"${SEMAPHORE_GIT_REF}": 2>/dev/null; then
      git checkout -qf FETCH_HEAD
      echo "HEAD is now at ${SEMAPHORE_GIT_SHA}"

      return 0
    fi

    echo "Revision: ${SEMAPHORE_GIT_SHA} not found .... Exiting"
    return 1
  fi

  if [ "${SEMAPHORE_GIT_REF_TYPE:-""}" = "tag" ]; then
    if ! retry git clone --depth "${SEMAPHORE_GIT_DEPTH}" -b "${SEMAPHORE_GIT_TAG_NAME}" "${SEMAPHORE_GIT_URL}" "${SEMAPHORE_GIT_DIR}"; then
      echo "Release $SEMAPHORE_GIT_TAG_NAME not found .... Exiting"
      return 1
    else
      cd "${SEMAPHORE_GIT_DIR}" || exit
      git checkout -qf "${SEMAPHORE_GIT_TAG_NAME}"
      echo "HEAD is now at ${SEMAPHORE_GIT_SHA} Release ${SEMAPHORE_GIT_TAG_NAME}"

      return 0
    fi
  fi

  checkout::shallow
}

function checkout::metric() {
  if [[ "${SEMAPHORE_TOOLBOX_METRICS_ENABLED:-''}" == "true" ]]; then
    ref_type=${SEMAPHORE_GIT_REF_TYPE:-""}
    size=${1:-"0"}
    [[ $size -gt 0 ]] && status='success' || status='fail'
    echo "libcheckout,provider='$SEMAPHORE_GIT_PROVIDER',reftype='$ref_type',status=$status size=$1" >> /tmp/toolbox_checkout
  fi
}

export -f checkout