compile

#!/bin/bash

set -e

set -o pipefail
shopt -s dotglob

basedir="$( cd -P "$( dirname "$0" )" && pwd )"
source "$basedir/../conf/buildpack.conf"
source $basedir/common.sh
source $basedir/../lib/package
source $basedir/../lib/composer
source $basedir/../lib/datadog
source $basedir/../lib/scout
source $basedir/../lib/newrelic
source $basedir/../lib/apt
source $basedir/../lib/pecl
source $basedir/../lib/pecl_oci8

if [ "$PHP_BUILDPACK_NO_NODE" != "true" ] ; then
  source $basedir/../lib/nodejs
fi

if [ -n "$BUILDPACK_DEBUG" ]; then
    set -x
fi

BUILD_DIR="$1"
CACHE_DIR="$2"
ENV_DIR="$3"

cd "$BUILD_DIR"
mkdir -p "$CACHE_DIR/package"

export APP_ENV=${APP_ENV:-prod}

function detect_framework() {
  BUILD_DIR=$1
  for f in "$basedir/../frameworks/"*; do
      if "$f" detect "$BUILD_DIR"; then
          FRAMEWORK=$f
          break
      fi
  done
}

function best_composer_version() {
  local require_composer=""

  if [ -f "${BUILD_DIR}/composer.json" ]; then
    require_composer=$(jq --raw-output ".extra.${composer_extra_key}.engines.composer // \"\"" < "$BUILD_DIR/composer.json")
  fi

  if [ -z "${require_composer}" ] ; then
    require_composer="${COMPOSER_VERSION:-${DEFAULT_COMPOSER}}"
  fi

  curl --fail --location --silent "${SEMVER_SERVER}/composer-${STACK}/resolve/${require_composer}"
}

function best_nginx_version() {
  local require_nginx=""

  if [ -f "${BUILD_DIR}/composer.json" ]; then
    for key in ".require.nginx" ".extra.${composer_extra_key}.engines.nginx"; do
      require_nginx=$(jq --raw-output "${key} // \"\"" < "${BUILD_DIR}/composer.json")
      [ -n "${require_nginx}" ] && break
    done
  fi

  if [ -z "${require_nginx}" ]; then
    require_nginx="${NGINX_VERSION:-${DEFAULT_NGINX}}"
  fi

  curl --fail --location --silent "${SEMVER_SERVER}/nginx-${STACK}/resolve/${require_nginx}"
}

function best_php_version() {
  local require_php=""

  # First check if we have something in composer.json
  # If so, this is the value we want. It must always prevail:
  if [ -f "${BUILD_DIR}/composer.json" ]; then
    for key in ".require.php" ".config.platform.php" ".extra.${composer_extra_key}.engines.php"; do
      require_php="$( jq --raw-output "${key} // \"\"" < "${BUILD_DIR}/composer.json" )"
      [ -n "${require_php}" ] && break
    done
  fi

  # If nothing is specified in composer.json
  # Or if this is a Classic app, we should check PHP_VERSION:
  if [ -z "${require_php}" ]; then
    require_php="${PHP_VERSION:-${DEFAULT_PHP}}"
  fi

  curl --fail --location --silent "${SEMVER_SERVER}/php-${STACK}/resolve/${require_php}"
}

function php_api_version() {
  basename "$(php-config --extension-dir)" | tr '-' ' ' | cut -f 5 -d ' '
}

function has_heroku_extra() {
  jq --raw-output '.extra.heroku // ""' < "$BUILD_DIR/composer.json"
}

function package_document_root() {
  jq --raw-output ".extra.${composer_extra_key}[\"document-root\"] // \"\"" < "$BUILD_DIR/composer.json"
}

function package_index_file() {
  jq --raw-output ".extra.${composer_extra_key}[\"index-document\"] // \"index.php\"" < "$BUILD_DIR/composer.json"
}

function package_framework() {
  jq --raw-output ".extra.${composer_extra_key}.framework // \"\"" < "$BUILD_DIR/composer.json"
}

function package_nginx_version() {
  jq --raw-output ".extra.${composer_extra_key}.engines.nginx // \"default\"" < "$BUILD_DIR/composer.json"
}

function package_php_config() {
  jq --raw-output ".extra.${composer_extra_key}[\"php-config\"] // [] | .[]" < "$BUILD_DIR/composer.json"
}

function package_php_includes() {
  jq --raw-output ".extra.${composer_extra_key}[\"php-includes\"] // [] | .[]" < "$BUILD_DIR/composer.json"
}

function package_php_fpm_config() {
  jq --raw-output ".extra.${composer_extra_key}[\"php-fpm-config\"] // [] | .[]" < "$BUILD_DIR/composer.json"
}

function package_php_fpm_includes() {
  jq --raw-output ".extra.${composer_extra_key}[\"php-fpm-includes\"] // [] | .[]" < "$BUILD_DIR/composer.json"
}

function package_nginx_http_includes() {
  jq --raw-output ".extra.${composer_extra_key}[\"nginx-http-includes\"] // [] | .[]" < "$BUILD_DIR/composer.json"
}

function package_nginx_includes() {
  jq --raw-output ".extra.${composer_extra_key}[\"nginx-includes\"] // [] | .[]" < "$BUILD_DIR/composer.json"
}

function package_log_files() {
  jq --raw-output ".extra.${composer_extra_key}[\"log-files\"] // [] | .[]" < "$BUILD_DIR/composer.json"
}

function package_access_log_format() {
  jq --raw-output ".extra.${composer_extra_key}[\"access-log-format\"] // \"\"" < "$BUILD_DIR/composer.json"
}

function package_compile_cmd() {
  jq --raw-output ".extra.${composer_extra_key}[\"compile\"] // [] | .[]" < "$BUILD_DIR/composer.json"
}

function package_datadog_enabled() {
  local val=$(jq --raw-output ".extra.${composer_extra_key}.datadog // false" < "$BUILD_DIR/composer.json")

  if [ "$val" = "true" ]; then
    return 0
  else
    return 1
  fi
}

function package_newrelic_enabled() {
  local val=$(jq --raw-output ".extra.${composer_extra_key}[\"new-relic\"] // false" < "$BUILD_DIR/composer.json")

  if [ "$val" = "true" ]; then
    return 0
  else
    return 1
  fi
}

function package_scout_enabled() {
  local val=$(jq --raw-output ".extra.${composer_extra_key}.scout // false" < "$BUILD_DIR/composer.json")

  if [ "$val" = "true" ]; then
    return 0
  else
    return 1
  fi
}

export_env_dir "$3"

# Create some required directories:
mkdir -p "${BUILD_DIR}/bin" "${BUILD_DIR}/vendor"

DEFAULT_PHP=$(curl --fail --location --silent "${SEMVER_SERVER}/php-${STACK}")
DEFAULT_NGINX=$(curl --fail --location --silent "${SEMVER_SERVER}/nginx-${STACK}")
DEFAULT_COMPOSER=$(curl --fail --location --silent "${SEMVER_SERVER}/composer-${STACK}")

# Read config variables from composer.json if it exists
if [ -f "$BUILD_DIR/composer.json" ]; then
  composer_extra_key="paas"
  if [ -n "$(has_heroku_extra)" ] ; then
    protip "Your composer.json is using the key 'extra' → 'heroku', you should switch to 'extra' → 'paas' for standardization"
    composer_extra_key="heroku"
  fi
fi

PHP_VERSION=$(best_php_version)
NGINX_VERSION=$(best_nginx_version)
COMPOSER_VERSION=$(best_composer_version)
DOCUMENT_ROOT="${DOCUMENT_ROOT:-}"
INDEX_DOCUMENT="${INDEX_DOCUMENT:-index.php}"
FRAMEWORK="${FRAMEWORK:-}"
PHP_EXTRA_CONFIG="${PHP_EXTRA_CONFIG:-}"
PHP_INCLUDES="${PHP_INCLUDES:-}"
PHP_FPM_INCLUDES="${PHP_FPM_INCLUDES:-}"
PHP_FPM_EXTRA_CONFIG="${PHP_FPM_EXTRA_CONFIG:-}"
COMPILE_CMD="${COMPILE_CMD:-}"
NGINX_HTTP_INCLUDES="${NGINX_HTTP_INCLUDES:-}"
NGINX_INCLUDES="${NGINX_INCLUDES:-}"
ACCESS_LOG_FORMAT_COMPOSER_JSON="${ACCESS_LOG_FORMAT_COMPOSER_JSON:-}"
DATADOG_TRACER_VERSION="${DATADOG_TRACER_VERSION:-latest}"
DATADOG_APPSEC_VERSION="${DATADOG_APPSEC_VERSION:-0}"
SCOUT_APM_VERSION=${SCOUT_APM_VERSION:-1.10.0}
# Version number comes from https://download.newrelic.com/php_agent/archive/
NEWRELIC_VERSION="${NEWRELIC_VERSION:=10.15.0.4}"
LOG_FILES=( "/app/vendor/nginx/logs/access.log" "/app/vendor/nginx/logs/error.log" "/app/vendor/php/var/log/error.log" )

# Display a warning that Composer version 1.x is End of Life
if [[ "$COMPOSER_VERSION" = 1.* ]]; then
  echo >&2 ""
  echo >&2 "######################################"
  echo >&2 "WARNING: You are using Composer ${COMPOSER_VERSION}. Composer 1 is End of Life since the 24th of October 2020 and will soon be deprecated."
  echo >&2 "https://doc.scalingo.com/languages/php/start#select-a-composer-version"
  echo >&2 "######################################"
  echo >&2 ""
fi

check_composer_syntax "$BUILD_DIR"
check_composer_json_and_lock "$BUILD_DIR"

# Read config variables from composer.json if it exists
if [ -f "$BUILD_DIR/composer.json" ]; then
  DOCUMENT_ROOT=$(package_document_root)
  INDEX_DOCUMENT=$(package_index_file)
  FRAMEWORK=$(package_framework)
  PHP_EXTRA_CONFIG=$(package_php_config)
  PHP_FPM_EXTRA_CONFIG=$(package_php_fpm_config)
  PHP_INCLUDES=$(package_php_includes)
  PHP_FPM_INCLUDES=$(package_php_fpm_includes)
  COMPILE_CMD=$(package_compile_cmd)
  NGINX_HTTP_INCLUDES=$(package_nginx_http_includes)
  NGINX_INCLUDES=$(package_nginx_includes)
  USER_LOG_FILES=$(package_log_files)
  ACCESS_LOG_FORMAT_COMPOSER_JSON=$(package_access_log_format)
fi

VENDORED_NGINX=/app/vendor/nginx
VENDORED_PHP=/app/vendor/php


status "Bundling Nginx ${NGINX_VERSION}"
fetch_engine_package nginx "$NGINX_VERSION" "${VENDORED_NGINX}" | indent

status "Bundling PHP ${PHP_VERSION}"

# Install libraries also on build container, so PHP doesn't complain about missing
# dynamic libraries when running it during the slug compilation.
fetch_package "$PHP_BASE_URL" "libmcrypt-${mcrypt_version}" /app/vendor/libmcrypt > /dev/null
fetch_package "$PHP_BASE_URL" "libzip-${zip_version}" /app/vendor/libzip > /dev/null
fetch_package "$PHP_BASE_URL" "libwebp-${webp_version}" /app/vendor/libwebp > /dev/null

fetch_engine_package php "$PHP_VERSION" "${VENDORED_PHP}" | indent

test ! -d ".profile.d" && mkdir -p .profile.d || true

cat > ".profile.d/php.sh" <<SH
export PATH=/app/bin:${VENDORED_NGINX}/sbin:${VENDORED_PHP}/sbin:${VENDORED_PHP}/bin:/app/vendor/bin:\$PATH
export APP_BUILD_TIME=$(date +%Y%m%d%H%M%S)
export LD_LIBRARY_PATH=/app/vendor/libonig:\$LD_LIBRARY_PATH
[ -d "/app/vendor/libsodium" ] && export LD_LIBRARY_PATH=/app/vendor/libsodium:\$LD_LIBRARY_PATH

# Set APP_ENV to prod by default for Symfony based framework.
export APP_ENV="\${APP_ENV:-prod}"

# Configure every how many request PHP-FPM recycle its worker, disabled by default
export PHP_FPM_MAX_REQUESTS="\${PHP_FPM_MAX_REQUESTS:-0}"
SH

if [ $STACK = "scalingo-14" ] ; then
    fetch_package "$PHP_BASE_URL" "tail-${coreutils_version}" /app/vendor/coreutils > /dev/null
fi

source ".profile.d/php.sh"

# Lib Oniguruma is only mandatory starting with PHP 7.4
if [[ "$(php_api_version)" -ge "${PHP_MODULE_API_VERSIONS["7.4"]}" ]] ; then
  fetch_package "$PHP_BASE_URL" "libonig-${libonig_version}" /app/vendor/libonig > /dev/null
  export LD_LIBRARY_PATH="/app/vendor/libonig:$LD_LIBRARY_PATH"
fi

# Fetch additional extensions
status "Bundling platform default extensions"
echo "       apcu"
fetch_package "$PHP_BASE_URL" "ext/$(php_api_version)/php-apcu" "/app/vendor/php" | indent

echo "       phpredis"
fetch_package "$PHP_BASE_URL" "ext/$(php_api_version)/php-redis" "/app/vendor/php" | indent

echo "       mongodb"
fetch_package "$PHP_BASE_URL" "ext/$(php_api_version)/php-mongodb" "/app/vendor/php" | indent

if [ "$(php_api_version)" = "20170718" -o "$(php_api_version)" = "20180731" ] ; then
    echo "       mcrypt"
    fetch_package "$PHP_BASE_URL" "ext/$(php_api_version)/php-mcrypt" "/app/vendor/php" | indent
fi

if [ -f "$BUILD_DIR/composer.json" ] && package_datadog_enabled; then
    install_datadog "${DATADOG_TRACER_VERSION}" "${DATADOG_APPSEC_VERSION}"
fi

if [ -f "$BUILD_DIR/composer.json" ] && package_scout_enabled; then
  install_scout "${SCOUT_APM_VERSION}"
fi

if [ -f "$BUILD_DIR/composer.json" ] && package_newrelic_enabled; then
    status "New Relic usage detected, installing Agent and PHP extension"
    LOG_FILES+=( "/app/vendor/newrelic/daemon.log" "/app/vendor/newrelic/agent.log" )
    install_newrelic "$NEWRELIC_VERSION"
    install_newrelic_user_config

    echo 'export NEW_RELIC_LOG_DAEMON=${NEW_RELIC_LOG_DAEMON:=/app/vendor/newrelic/daemon.log}' >> ".profile.d/php.sh"
    echo 'export NEW_RELIC_LOG_AGENT=${NEW_RELIC_LOG_AGENT:=/app/vendor/newrelic/agent.log}' >> ".profile.d/php.sh"
fi

if [ -n "$BLACKFIRE_SERVER_ID" -a -n "$BLACKFIRE_SERVER_TOKEN" ] ; then
    status "Blackfire usage detected, installing PHP extension"
    fetch_package "$PHP_BASE_URL" "ext/$(php_api_version)/php-blackfire" "/app/vendor/php" | indent
    cp /app/vendor/php/bin/profile.blackfire.sh $BUILD_DIR/.profile.d
fi

if [ -n "$BUILDPACK_DEBUG" ]; then
    ls -R /app/vendor/nginx
    ls -R /app/vendor/php
fi

mkdir -p "conf"
cp "$basedir/util/autotune.php" "conf/autotune.php"
cp "$basedir/../conf/nginx/base.conf.erb" "conf/nginx.conf.erb"
# Fix dirty logging on stdout/stderr (WARNING child with PID said on stderr). It
# has been fixed in PHP 7.3 (https://github.com/php/php-src/pull/2458) with a
# custom php-fpm parameter: `decorate_workers_output`
if [[ "$(php_api_version)" -gt "${PHP_MODULE_API_VERSIONS["7.2"]}" ]] ; then
  cp "$basedir/../conf/php/php-fpm-73.conf" "/app/vendor/php/etc/php-fpm.conf"
else
  cp "$basedir/../conf/php/php-fpm.conf" "/app/vendor/php/etc/php-fpm.conf"
fi
cp "$basedir/../conf/php/php.ini" "/app/vendor/php/etc/php.ini"

mkdir -p /app/vendor/php/etc/fpm.d

echo "; extra configuration for php fpm" >> "/app/vendor/php/etc/fpm.d/extra.conf"

# IFS= to set on multiple line each configuration item
OLDIFS=$IFS
IFS=
echo $PHP_EXTRA_CONFIG | while read conf ; do
    echo "$conf" >> "/app/vendor/php/etc/php.ini"
done

echo $PHP_FPM_EXTRA_CONFIG | while read conf ; do
    echo "$conf" >> "/app/vendor/php/etc/fpm.d/extra.conf"
done
IFS=$OLDIFS

for include in $PHP_INCLUDES; do
    cp "$BUILD_DIR/$include" "/app/vendor/php/etc/conf.d/"
done

if [ -n "$PHP_FPM_INCLUDES" ] ; then
    for include in $PHP_FPM_INCLUDES; do
        cp "$BUILD_DIR/$include" "/app/vendor/php/etc/fpm.d/"
    done
fi

if [ "$PHP_BUILDPACK_NO_NODE" != "true" ] ; then
  install_node_deps "$BUILD_DIR"
fi

install_composer_deps "${BUILD_DIR}" "${CACHE_DIR}" "${ENV_DIR}"

# Detect PHP framework
# Set FRAMEWORK if not set in environment by user
if [ -z "$FRAMEWORK" ]; then
    detect_framework "$BUILD_DIR"
fi

# Fall back to classic mode
if [ -z "$FRAMEWORK" ]; then
    FRAMEWORK="$basedir/../frameworks/default"
fi

# Try to load the framework from the "frameworks" directory if it's just a
# simple framework name like "symfony"
if [ -f "$basedir/../frameworks/$FRAMEWORK" ]; then
    FRAMEWORK="$basedir/../frameworks/$FRAMEWORK"
fi

if [ ! -f "$FRAMEWORK" ]; then
    error "Framework \"$FRAMEWORK\" not found!"
fi

"$FRAMEWORK" compile "$BUILD_DIR" "$CACHE_DIR"

LOG_FILES=$(unique_array ${LOG_FILES[@]} ${USER_LOG_FILES[@]})
if [ -n "$FRAMEWORK" ] && [ -f "$FRAMEWORK" ]; then
    FRAMEWORK_LOG_FILES=$("$FRAMEWORK" get-log-files "$BUILD_DIR")
    LOG_FILES=$(unique_array ${LOG_FILES[@]} ${FRAMEWORK_LOG_FILES[@]})
fi

if [ -n "$COMPILE_CMD" ]; then
    status "Running compile commands"
    while read -r cmd; do
        echo "Running '$cmd'" | indent
        eval $cmd             | indent
    done <<< "$COMPILE_CMD"
fi

if [ -n "$FRAMEWORK" ] && [ -f "$FRAMEWORK" ]; then
    "$FRAMEWORK" end "$BUILD_DIR" "$CACHE_DIR"
fi

"$FRAMEWORK" post-compile "$BUILD_DIR" "$CACHE_DIR" || true

status "Vendoring binaries into slug"

mv /app/vendor/nginx vendor/nginx
mv /app/vendor/php vendor/php
[ -d "/app/vendor/libmcrypt" ] && mv /app/vendor/libmcrypt vendor/libmcrypt
[ -d "/app/vendor/libonig" ] && mv /app/vendor/libonig vendor/libonig
[ -d "/app/vendor/libzip" ] && mv /app/vendor/libzip vendor/libzip
[ -d "/app/vendor/coreutils" ] && mv /app/vendor/coreutils vendor/coreutils
[ -d "/app/vendor/libmemcached" ] && mv /app/vendor/libmemcached vendor/libmemcached
[ -d "/app/vendor/gmp" ] && mv /app/vendor/gmp vendor/gmp
[ -d "/app/vendor/libtidy" ] && mv /app/vendor/libtidy vendor/libtidy
[ -d "/app/vendor/libsodium" ] && mv /app/vendor/libsodium vendor/libsodium
[ -d "/app/vendor/libwebp" ] && mv /app/vendor/libwebp vendor/libwebp
[ -d "/app/vendor/oracle-client" ] && mv /app/vendor/oracle-client vendor/oracle-client

mkdir -p "bin" "vendor/bin"

if [ "$STACK" = "scalingo-14" ] ; then
    test ! -f "bin/tail" && ln -s "/app/vendor/coreutils/bin/tail" "bin/tail"
fi

# If this buildpack is run after the nodejs buildpack remove the WEB_CONCURRENCY script
if [ -f "$BUILD_DIR/.profile.d/WEB_CONCURRENCY.sh" ] ; then
  rm "$BUILD_DIR/.profile.d/WEB_CONCURRENCY.sh"
fi

cat > "bin/run" <<SH
#!/usr/bin/env bash

pmsgr=/tmp/pmsgr
rm -f \$pmsgr
mkfifo \$pmsgr

# Loop through all environment variables. Work even though there are multi-lines
# env variables.
env -0 | while IFS='=' read -r -d '' name value; do
    echo "env[\$name] = \\$\${name}" >> /app/vendor/php/etc/php-fpm.conf
done

export DOCUMENT_ROOT="\${DOCUMENT_ROOT:-$DOCUMENT_ROOT}"
export INDEX_DOCUMENT="\${INDEX_DOCUMENT:-$INDEX_DOCUMENT}"
export NGINX_HTTP_INCLUDES="\${NGINX_HTTP_INCLUDES:-$NGINX_HTTP_INCLUDES}"
export NGINX_INCLUDES="\${NGINX_INCLUDES:-$NGINX_INCLUDES}"
export ACCESS_LOG_FORMAT_COMPOSER_JSON='$ACCESS_LOG_FORMAT_COMPOSER_JSON'
export ACCESS_LOG_FORMAT="\${ACCESS_LOG_FORMAT:-\$ACCESS_LOG_FORMAT_COMPOSER_JSON}"

if [ -f "/app/vendor/php/etc/conf.d/newrelic.ini" ] ; then
    if [ -n "\$NEW_RELIC_LICENSE_KEY" ]; then
        echo "newrelic.license=\"\$NEW_RELIC_LICENSE_KEY\"" > /app/vendor/php/etc/conf.d/newrelic_license.ini
    else
        echo " !"
        echo " ! New Relic agent has been installed but is misconfigured"
        echo " ! NEW_RELIC_LICENSE_KEY should be define in the application environment"
        echo " !"
        echo " ! Documentation: https://doc.scalingo.com/languages/php/start"
        echo " !"
    fi
fi

erb conf/nginx.conf.erb > /app/vendor/nginx/conf/nginx.conf
erb conf/site.conf.erb > /app/vendor/nginx/conf/site.conf

if [[ -z \${WEB_CONCURRENCY:-} ]]; then
    ram="512M"
    container_size=\${CONTAINER_SIZE:-M}
    if [ \$container_size = "S" ] ; then
        ram="256M"
    elif [ \$container_size = "L" ] ; then
        ram="1024M"
    elif [ \$container_size = "XL" ] ; then
        ram="2048M"
    elif [ \$container_size = "2XL" ] ; then
        ram="4096M"
    elif [ \$container_size = "3XL" ] ; then
        ram="8182M"
    fi

    echo "Optimizing defaults for \${container_size} container..." >&2

    # determine number of FPM processes to run
    read WEB_CONCURRENCY php_memory_limit <<<\$(php -c "/app/vendor/php/etc/php.ini" /app/conf/autotune.php -y "/app/vendor/php/etc/php-fpm.conf" -t "\$DOCUMENT_ROOT" "\$ram")
    [[ \$WEB_CONCURRENCY -lt 3 ]] && WEB_CONCURRENCY=3
    export WEB_CONCURRENCY
    echo "\${WEB_CONCURRENCY} processes at \${php_memory_limit}B memory limit." >&2
else
    echo "Using WEB_CONCURRENCY=\${WEB_CONCURRENCY} processes." >&2
fi

`init_log_plex ${LOG_FILES}`
`tail_log_plex ${LOG_FILES} ${SYS_LOG_FILES}`

(
    php-fpm -p "/app/vendor/php"
    echo "php-fpm" > \$pmsgr
)&

(
    nginx -p "/app/vendor/nginx" -c /app/vendor/nginx/conf/nginx.conf
    echo "nginx" > \$pmsgr
)&


read exitproc <\$pmsgr
echo "Boot failed: \$exitproc"
exit 1
SH

chmod +x "bin/run"