sda-php
/
nulib
11
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

début d'implémentation runphp standalone

This commit is contained in:
Jephté Clain 2024-10-18 12:33:36 +04:00
parent d923ec8940
commit 438b63f8e0
7 changed files with 689 additions and 71 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

0
bin_wip/composer → bin/composer
View File

569
bin/lib-runphp/runphp Executable file
View File

@ -0,0 +1,569 @@
#!/bin/bash
# -*- coding: utf-8 mode: sh -*- vim:sw=4:sts=4:et:ai:si:sta:fenc=utf-8
# Script permettant de lancer une commande dans docker et/ou de bootstrapper
# l'utilisation de nulib dans un projet PHP
# Les fichiers suivants doivent être copiés à un endroit quelconque du projet:
# - runphp (ce script, à générer avec update-runphp.sh)
# - Dockerfile.runphp
# Les fichiers suivants peuvent être intégrés dans le projet comme exemples:
# - dot-build.env.dist (à renommer en .build.env.dist)
# - dot-dkbuild.env.dist (indiquer qu'il faut le copier en ~/.dkbuild.env)
# Par défaut, ce script assume que runphp est copié dans le répertoire sbin/
# du projet, et que le fichier composer.json et le répertoire vendor/ sont à la
# racine du projet. Le cas échéant, modifier les valeurs ci-dessous
(return 0 2>/dev/null) && _sourced=1 || _sourced=
###############################################################################
# Modifier les valeurs suivantes si nécessaire
#SOF:runphp.userconf:ne pas modifier cette ligne
# répertoire du projet. ce chemin doit être absolu. s'il est relatif, il est
# exprimé par rapport au répertoire de ce script
PROJDIR=
# composer: répertoire du projet composer (celui qui contient le fichier
# composer.json), chemin de composer.phar et répertoire vendor. ces chemins
# doivent être relatifs à $PROJDIR
COMPOSERDIR=
COMPOSERPHAR=
VENDORDIR=
# fichier de configuration pour le build
BUILDENV0=
BUILDENV=
# Listes des images que le script build construit automatiquement
BUILD_IMAGES=()
BUILD_FLAVOUR=
## En ce qui concerne DIST et IMAGENAME, les valeurs dans BUILDENV prennent le
## dessus. si BUILDENV *n'est pas* utilisé, ces valeurs peuvent être spécifiées
## ici
# version de debian à utiliser pour l'image
# d12=php8.2, d11=php7.4, d10=php7.3
DIST=
# Nom de base de l'image (sans le registry), e.g prefix/
IMAGENAME=
#EOF:runphp.userconf:ne pas modifier cette ligne
################################################################################
# Ne pas modifier à partir d'ici
if [ -n "$_sourced" ]; then
if [ "${0#-}" != "$0" ]; then
# sourcé depuis la ligne de commande
MYSELF="${BASH_SOURCE[1]}"
else
# sourcé depuis un script
MYSELF="${BASH_SOURCE[0]}"
fi
MYDIR="$(cd "$(dirname -- "$MYSELF")"; pwd)"
MYNAME="$(basename -- "$MYSELF")"
else
MYDIR="$(cd "$(dirname -- "$0")"; pwd)"
MYNAME="$(basename -- "$0")"
fi
if [ -f "$MYDIR/runphp.userconf.local" ]; then
source "$MYDIR/runphp.userconf.local"
fi
if [ -n "$RUNPHP_STANDALONE" ]; then
PROJDIR="$RUNPHP_PROJDIR"
COMPOSERDIR=.
COMPOSERPHAR=
VENDORDIR=vendor
BUILDENV0=
BUILDENV=
DIST="$RUNPHP_DIST"
IMAGENAME=nulib/
PRIVAREG=docker.io
REGISTRY="$RUNPHP_REGISTRY"
else
[ -n "$PROJDIR" ] || PROJDIR="$(dirname -- "$MYDIR")"
[ "${PROJDIR#/}" != "$PROJDIR" ] || PROJDIR="$(cd "$MYDIR/$PROJDIR"; pwd)"
[ -n "$COMPOSERDIR" ] || COMPOSERDIR=.
[ -n "$COMPOSERPHAR" ] || COMPOSERPHAR=sbin/composer.phar
[ -n "$VENDORDIR" ] || VENDORDIR=vendor
[ -n "$BUILDENV0" ] || BUILDENV0=.build.env.dist
[ -n "$BUILDENV" ] || BUILDENV=build.env
[ -n "$DIST" ] || DIST=d12
[ -n "$IMAGENAME" ] || IMAGENAME=nulib/
[ "$COMPOSERPHAR" == none ] && COMPOSERPHAR=
[ "$BUILDENV0" == none ] && BUILDENV0=
[ "$BUILDENV" == none ] && BUILDENV=
fi
function after_source_buildenv() {
NDIST="${DIST#d}"
}
after_source_buildenv
[ -n "$_sourced" ] && return 0
function eecho() { echo "$*" 1>&2; }
function eerror() { eecho "ERROR: $*"; }
function die() { [ $# -gt 0 ] && eerror "$*"; exit 1; }
function is_defined() { [ -n "$(declare -p "$1" 2>/dev/null)" ]; }
function in_path() { [ -n "$1" -a -x "$(which "$1" 2>/dev/null)" ]; }
function composer() {
cd "$PROJDIR/$COMPOSERDIR" || exit 1
if [ -n "$COMPOSERPHAR" -a -x "$PROJDIR/$COMPOSERPHAR" ]; then
"$PROJDIR/$COMPOSERPHAR" "$@"
elif in_path composer; then
command composer "$@"
elif [ -x /usr/bin/composer ]; then
/usr/bin/composer "$@"
elif [ -x /usr/local/bin/composer ]; then
/usr/local/bin/composer "$@"
else
die "impossible de trouver composer"
fi
if [ -z "$RUNPHP_STANDALONE" -a -f composer.lock ]; then
cp composer.lock "$PROJDIR/.composer.lock.runphp"
fi
}
function ensure_image() {
local privareg imagename
if [ -z "$IMAGE" ]; then
[[ "$IMAGENAME" == */ ]] && imagename=runphp || imagename="${IMAGENAME%/*}/runphp"
privareg="$PRIVAREG"
if [ "$imagename" == runphp ]; then
[ -z "$privareg" -o "$privareg" == docker.io ] && privareg=docker.io/library
else
[ -z "$privareg" ] && privareg=docker.io
fi
IMAGE="$privareg/$imagename:$DIST"
fi
}
function check_image() {
local image="$IMAGE"
for prefix in docker.io/library/ docker.io; do
if [ "${image#$prefix}" != "$image" ]; then
image="${image#$prefix}"
break
fi
done
[ -n "$(docker image ls --no-trunc --format '{{.Repository}}:{{.Tag}}' "$image" 2>/dev/null)" ]
}
bootstrap=
BootstrapOnly=1
ComposerInstall=
ForcedBootstrap=
parse_opts=1
args=()
for arg in "$@"; do
if [ -z "$parse_opts" ]; then
args+=("$arg")
elif [ "$arg" == --bootstrap -o "$arg" == --bs ]; then
bootstrap=1
elif [ "$arg" == --exec ]; then
BootstrapOnly=
elif [ "$arg" == --composer-install -o "$arg" == --ci ]; then
ComposerInstall=1
elif [[ "$arg" == -* ]]; then
args+=("$arg")
else
args+=("$arg")
parse_opts=
fi
done
set -- "${args[@]}"
if [ -z "$RUNPHP_STANDALONE" -a -z "$bootstrap" ]; then
# si vendor/ n'existe pas, alors on doit faire bootstrap
if [ ! -f "$PROJDIR/$VENDORDIR/nulib/php/load.sh" ]; then
ForcedBootstrap=1
elif [ ! -f "$PROJDIR/.composer.lock.runphp" ]; then
ForcedBootstrap=1
elif ! diff -q "$PROJDIR/$COMPOSERDIR/composer.lock" "$PROJDIR/.composer.lock.runphp" >&/dev/null; then
ForcedBootstrap=1
elif [ -n "$bootstrap" -a -n "$BootstrapOnly" ]; then
# bootstrap inutile
exit 0
fi
if [ -n "$ForcedBootstrap" ]; then
[ "$RUNPHP_MODE" != docker ] && eecho "== runphp is needed: bootstrapping"
bootstrap=1
BootstrapOnly=
fi
fi
if [ "$RUNPHP_MODE" != docker ]; then
############################################################################
# Lancement depuis l'extérieur du container
# recenser les valeur de proxy
declare -A PROXY_VARS
for var in {HTTPS,ALL,NO}_PROXY {http,https,all,no}_proxy; do
is_defined "$var" && PROXY_VARS[${var,,}]="${!var}"
done
## Charger ~/.dkbuild.env
APT_PROXY=
APT_MIRROR=
SEC_MIRROR=
TIMEZONE=
PRIVAREG=
REGISTRY=
PROFILE=
HOST_MAPPINGS=()
function default_profile() {
PROFILE="$1"
}
function profile() {
local profile
for profile in "$@"; do
[ "$profile" == "$PROFILE" ] && return 0
done
return 1
}
function setenv() {
eval "export $1"
}
function default() {
local command="$1"; shift
local nv n v
case "$command" in
docker)
for nv in "$@"; do
[[ "$nv" == *=* ]] || continue
n="${nv%%=*}"
v="${nv#*=}"
case "$n" in
host-mappings)
read -a ns <<<"$v"
for v in "${ns[@]}"; do
HOST_MAPPINGS+=("$v")
done
;;
esac
done
;;
esac
}
[ -f ~/.dkbuild.env ] && source ~/.dkbuild.env
[ -n "$APT_PROXY" ] || APT_PROXY=
[ -n "$APT_MIRROR" ] || APT_MIRROR=default
[ -n "$SEC_MIRROR" ] || SEC_MIRROR=default
[ -n "$TIMEZONE" ] || TIMEZONE=Europe/Paris
[ -n "$PRIVAREG" ] || PRIVAREG=
[ -n "$REGISTRY" ] || REGISTRY=pubdocker.univ-reunion.fr
## Construire l'image
if [ -n "$RUNPHP_NO_USE_RSLAVE" ]; then
UseRslave=
elif [ -n "$RUNPHP_USE_RSLAVE" ]; then
UseRslave=1
elif [ -e /proc/sys/fs/binfmt_misc/WSLInterop ]; then
# pas de mount propagation sous WSL
UseRslave=
else
UseRslave=1
fi
IMAGE=
if [ -z "$bootstrap" ]; then
if [ -n "$RUNPHP_FORCE_BUILDENVS" ]; then
eval "Configs=($RUNPHP_FORCE_BUILDENVS)"
for config in "${Configs[@]}"; do
source "$config" || exit 1
done
after_source_buildenv
elif [ -n "$BUILDENV" -a -f "$PROJDIR/$BUILDENV" ]; then
source "$PROJDIR/$BUILDENV" || exit 1
after_source_buildenv
elif [ -n "$BUILDENV0" -a -f "$PROJDIR/$BUILDENV0" ]; then
source "$PROJDIR/$BUILDENV0" || exit 1
after_source_buildenv
fi
ensure_image
check_image || bootstrap=1
fi
if [ -n "$bootstrap" ]; then
BUILD_ARGS=(
DIST NDIST
REGISTRY
APT_PROXY
APT_MIRROR
SEC_MIRROR
TIMEZONE
)
SOPTS=+d:9876543210:c:UjDx:z:r:pw:v
LOPTS=help,dist:,d19,d18,d17,d16,d15,d14,d13,d12,d11,d10,config:,ue,unless-exists,pull,nc,no-cache,po,plain-output,apt-proxy:,timezone:,privareg:,push,chdir:,verbose,no-use-rslave
args="$(getopt -n "$MYNAME" -o "$SOPTS" -l "$LOPTS" -- "$@")" || exit 1; eval "set -- $args"
Dist=
if [ -n "$RUNPHP_FORCE_BUILDENVS" ]; then
eval "Configs=($RUNPHP_FORCE_BUILDENVS)"
elif [ -n "$BUILDENV" -a -f "$PROJDIR/$BUILDENV" ]; then
Configs=("$PROJDIR/$BUILDENV")
elif [ -n "$BUILDENV0" -a -f "$PROJDIR/$BUILDENV0" ]; then
Configs=("$PROJDIR/$BUILDENV0")
else
Configs=()
fi
UnlessExists=
Pull=
NoCache=
PlainOutput=
Chdir=
Verbose=
while [ $# -gt 0 ]; do
case "$1" in
--) shift; break;;
--help)
eecho "\
runphp: construire l'image docker
USAGE
$MYNAME --bootstrap [options...] [--exec command [args...]]
OPTIONS
-c, --config build.env
--unless-exists
-U, --pull
-j, --no-cache
-D, --plain-output
-x, --apt-proxy APT_PROXY
-z, --timezone TIMEZONE
-r, --privareg PRIVAREG
-p, --push
paramètres pour la consruction de l'image
-w, --chdir CHDIR
aller dans le répertoire spécifié avant de lancer la commande
-v, --verbose
afficher plus d'informations"
exit 0
;;
-d|--dist) shift; Dist="$1";;
-[0-9]) Dist="d1${1#-}";;
--d*) Dist="${1#--}";;
-c|--config) shift; Configs+="$1";;
--ue|--unless-exists) UnlessExists=1;;
-U|--pull) Pull=1;;
-j|--nc|--no-cache) NoCache=1;;
-D|--po|--plain-output) PlainOutput=1;;
-x|--apt-proxy) shift; APT_PROXY="$1";;
-z|--timezone) shift; TIMEZONE="$1";;
-r|--privareg) shift; PRIVAREG="$1";;
-p|--push) Push=1;;
-w|--chdir) shift; Chdir="$1";;
-v|--verbose) Verbose=1;;
--no-use-rslave) UseRslave=;;
*) die "$1: option non configurée";;
esac
shift
done
for config in "${Configs[@]}"; do
if [ "$config" == none ]; then
Configs=()
break
fi
done
if [ ${#Configs[*]} -gt 0 ]; then
for config in "${Configs[@]}"; do
source "$config" || exit 1
done
after_source_buildenv
fi
[ -n "$Dist" ] && DIST="$Dist"
ensure_image
check_image && exists=1 || exists=
if [ -z "$UnlessExists" -o -z "$exists" ]; then
eecho "== Building $IMAGE"
dockerfiles=(
"$MYDIR/Dockerfile.runphp.local"
"$MYDIR/Dockerfile.runphp$BUILD_FLAVOUR"
"$MYDIR/Dockerfile.runphp"
)
for dockerfile in "${dockerfiles[@]}"; do
[ -f "$dockerfile" ] && break
done
args=(
-f "$dockerfile"
${Pull:+--pull}
${NoCache:+--no-cache}
${BuildPlain:+--progress plain}
-t "$IMAGE"
)
for arg in "${BUILD_ARGS[@]}"; do
args+=(--build-arg "$arg=${!arg}")
done
for arg in "${!PROXY_VARS[@]}"; do
args+=(--build-arg "$arg=${PROXY_VARS[$arg]}")
done
for host in "${HOST_MAPPINGS[@]}"; do
args+=(--add-host "$host")
done
mkdir -p /tmp/runphp-build
docker build "${args[@]}" /tmp/runphp-build || exit 1
if [ -n "$Push" -a -n "$PRIVAREG" ]; then
eecho "== Pushing $IMAGE"
docker push "$IMAGE" || exit 1
fi
fi
if [ -n "$ComposerInstall" -a ! -f "$PROJDIR/$VENDORDIR/nulib/php/load.sh" ]; then
BootstrapOnly=
ForcedBootstrap=1
fi
[ -n "$BootstrapOnly" ] && exit 0
else
SOPTS=+w:v
LOPTS=help,chdir:,verbose,no-use-rslave
args="$(getopt -n "$MYNAME" -o "$SOPTS" -l "$LOPTS" -- "$@")" || exit 1; eval "set -- $args"
Chdir=
Verbose=
while [ $# -gt 0 ]; do
case "$1" in
--) shift; break;;
--help)
eecho "\
runphp: lancer une commande dans docker
USAGE
$MYNAME ci|cu|composer
$MYNAME --exec [options...] command [args...]
COMMANDES COMPOSER
ci
cu
installer/mettre à jour les dépendances du projet avec composer
composer (args...]
lancer composer avec les arguments spécifiés.
pour les commandes ci-dessus, l'option --chdir est ignorée: le répertoire
courant est forcé au répertoire du projet composer
OPTIONS
-w, --chdir CHDIR
aller dans le répertoire spécifié avant de lancer la commande
-v, --verbose
afficher plus d'informations"
exit 0
;;
-w|--chdir) shift; Chdir="$1";;
-v|--verbose) Verbose=1;;
--no-use-rslave) UseRslave=;;
*) die "$1: option non configurée";;
esac
shift
done
if [ -n "$ComposerInstall" -a ! -f "$PROJDIR/$VENDORDIR/nulib/php/load.sh" ]; then
# Forcer l'installation des dépendances si nécessaire
ForcedBootstrap=1
fi
fi
## Lancer la commande
args=(
run -it --rm
--name "runphp-$(basename -- "$1")-$$"
-e RUNPHP_MODE=docker
)
for arg in "${!PROXY_VARS[@]}"; do
args+=(--e "$arg=${PROXY_VARS[$arg]}")
done
for host in "${HOST_MAPPINGS[@]}"; do
args+=(--add-host "$host")
done
# monter le répertoire qui contient $PROJDIR
mount_composer=
if [ "${PROJDIR#$HOME/}" != "$PROJDIR" -o "$PROJDIR" == "$HOME" ]; then
# bind mount $HOME
args+=(-v "$HOME:$HOME${UseRslave:+:rslave}")
else
# bind mount uniquement le répertoire du projet
args+=(-v "$PROJDIR:$PROJDIR${UseRslave:+:rslave}")
mount_composer=1
fi
if [ -n "$mount_composer" -a -d "$HOME/.composer" ]; then
# monter la configuration de composer
args+=(-v "$HOME/.composer:$HOME/.composer")
fi
args+=(-w "$(pwd)")
# lancer avec l'utilisateur courant
if [ $(id -u) -ne 0 ]; then
# si c'est un utilisateur lambda, il faut monter les informations
# nécessaires. composer est déjà monté via $HOME
args+=(
-e DEVUSER_USERENT="$(getent passwd "$(id -un)")"
-e DEVUSER_GROUPENT="$(getent group "$(id -gn)")"
)
fi
args+=(
"$IMAGE"
exec "$0" ${Chdir:+-w "$Chdir"}
)
[ -n "$ForcedBootstrap" ] && set -- ci
[ -n "$Verbose" ] && eecho "\$ docker ${args[*]} $*"
exec docker "${args[@]}" "$@"
else
############################################################################
# Lancement depuis l'intérieur du container
if [ -n "$DEVUSER_USERENT" ]; then
user="${DEVUSER_USERENT%%:*}"
export DEVUSER_USERENT=
export DEVUSER_GROUPENT=
if in_path su-exec; then
exec su-exec "$user" "$0" "$@"
else
exec runuser -u "$user" -- "$0" "$@"
fi
fi
SOPTS=+w:
LOPTS=chdir:
args="$(getopt -n "$MYNAME" -o "$SOPTS" -l "$LOPTS" -- "$@")" || exit 1; eval "set -- $args"
chdir=
action=
while [ $# -gt 0 ]; do
case "$1" in
--) shift; break;;
-w|--chdir) shift; chdir="$1";;
*) die "$1: option non configurée";;
esac
shift
done
if [ "$1" == ci ]; then
eecho "== installing composer dependencies"
composer i
elif [ "$1" == cu ]; then
eecho "== upgrading composer dependencies"
composer u
elif [ "$1" == composer ]; then
"$@"
else
if [ -n "$chdir" ]; then
cd "$chdir" || exit 1
fi
exec "${@:-bash}"
fi
fi

73
bin/runphp Executable file
View File

@ -0,0 +1,73 @@
#!/bin/bash
# -*- coding: utf-8 mode: sh -*- vim:sw=4:sts=4:et:ai:si:sta:fenc=utf-8
source "$(dirname -- "$0")/../load.sh" || exit 1
function runphp_help() {
echo "$MYNAME: lance un programme dans un environnement PHP prédéfini pour le projet
USAGE
$MYNAME ci|cu|composer
$MYNAME command [args...]
COMPOSER
pour ces commandes, le répertoire courant est forcé au répertoire du projet
composer
ci
installer les dépendances du projet avec composer
cu
mettre à jour les dépendances du projet avec composer
composer [args...]
lancer composer avec les arguments spécifiés
COMMAND"
}
SOPTS=+
LOPTS=help
args="$(getopt -n runphp -o "$SOPTS" -l "$LOPTS" -- "$@")" || exit 1; eval "set -- $args"
while [ $# -gt 0 ]; do
case "$1" in
--) shift; break;;
--help) runphp_help; exit 0;;
*) die "$1: option non configurée";;
esac
shift
done
# chercher d'abord le répertoire du projet
PROJDIR=
while true; do
cwd="$(pwd)"
if [ -f .runphp.conf ]; then
PROJDIR="$cwd"
break
elif [ -f composer.json ]; then
PROJDIR="$cwd"
break
fi
if [ "$cwd" == "$HOME" -o "$cwd" == / ]; then
die "Impossible de trouver un projet PHP"
fi
cd ..
done
export RUNPHP_STANDALONE=
RUNPHP=; DIST=; REGISTRY=
if [ -f "$PROJDIR/.runphp.conf" ]; then
source "$PROJDIR/.runphp.conf"
[ -n "$RUNPHP" ] && exec "$PROJDIR/$RUNPHP" "$@"
elif [ -f "$PROJDIR/sbin/runphp" ]; then
exec "$PROJDIR/sbin/runphp" "$@"
fi
[ -n "$DIST" ] || DIST=d12
[ -x "$MYDIR/$DIST/runphp" ] || die "$DIST: distribution non supportée"
export RUNPHP_STANDALONE=1
export RUNPHP_PROJDIR="$PROJDIR"
export RUNPHP_REGISTRY="$REGISTRY"
export RUNPHP_DIST="$DIST"
"$MYDIR/$DIST/runphp" "$@"

51
bin_wip/runphp
View File

@ -1,51 +0,0 @@
#!/bin/bash
# -*- coding: utf-8 mode: sh -*- vim:sw=4:sts=4:et:ai:si:sta:fenc=utf-8
source "$(dirname -- "$0")/../load.sh" || exit 1
case "$MYNAME" in
runphp) ;;
composer)
if [ -f "$MYDIR/composer.phar" ]; then
set -- "$MYDIR/composer.phar" "$@"
elif [ -f "$MYDIR/../sbin/composer.phar" ]; then
set -- "$MYDIR/../sbin/composer.phar" "$@"
elif [ -f "/usr/bin/composer" ]; then
set -- "/usr/bin/composer" "$@"
else
set -- "" "$@"
fi
;;
*) die "$MYNAME: nom de script invalide";;
esac
function runphp_help() {
echo "$MYNAME: lance un programme PHP en sélectionnant une version en particulier
USAGE
$MYNAME [options] <SCRIPT.php> [args...]
OPTIONS
-s, --min PHP_MIN
-m, --max PHP_MAX
-i, --image IMAGE"
}
SOPTS=+smi
LOPTS=help,php-min,min,php-max,max,image
args="$(getopt -n runphp -o "$SOPTS" -l "$LOPTS" -- "$@")" || exit 1; eval "set -- $args"
while [ $# -gt 0 ]; do
case "$1" in
--) shift; break;;
--help) runphp_help; exit 0;;
*) die "$1: option non configurée";;
esac
shift
done
script="$1"; shift
[ -n "$script" ] || die "vous devez spécifier le script à lancer"
[ -f "$script" ] || die "$script: script introuvable"
scriptdir="$(dirname -- "$script")"
scritname="$(basename -- "$script")"

1
runphp/build
View File

@ -3,6 +3,7 @@
MYDIR="$(cd "$(dirname -- "$0")"; pwd)"
RUNPHP="$MYDIR/runphp"
"$RUNPHP" --bs --ue --ci || exit 1
RUNPHP_STANDALONE=
PROJDIR=; COMPOSERDIR=; COMPOSERPHAR=; VENDORDIR=; BUILDENV0=; BUILDENV=
BUILD_IMAGES=(php-apache mariadb10); export BUILD_FLAVOUR=; DIST=; IMAGENAME=
source "$RUNPHP" || exit 1

8
runphp/dot-runphp.conf Normal file
View File

@ -0,0 +1,8 @@
# -*- coding: utf-8 mode: sh -*- vim:sw=4:sts=4:et:ai:si:sta:fenc=utf-8
# Chemin vers runphp, e.g sbin/runphp
RUNPHP=
# Si RUNPHP n'est pas défini, les variables suivantes peuvent être définies
#DIST=d12
#REGISTRY=pubdocker.univ-reunion.fr

58
runphp/runphp.2postamble
View File

@ -21,20 +21,36 @@ if [ -f "$MYDIR/runphp.userconf.local" ]; then
source "$MYDIR/runphp.userconf.local"
fi
[ -n "$PROJDIR" ] || PROJDIR="$(dirname -- "$MYDIR")"
[ "${PROJDIR#/}" != "$PROJDIR" ] || PROJDIR="$(cd "$MYDIR/$PROJDIR"; pwd)"
if [ -n "$RUNPHP_STANDALONE" ]; then
PROJDIR="$RUNPHP_PROJDIR"
[ -n "$COMPOSERDIR" ] || COMPOSERDIR=.
[ -n "$COMPOSERPHAR" ] || COMPOSERPHAR=sbin/composer.phar
[ -n "$VENDORDIR" ] || VENDORDIR=vendor
[ -n "$BUILDENV0" ] || BUILDENV0=.build.env.dist
[ -n "$BUILDENV" ] || BUILDENV=build.env
[ -n "$DIST" ] || DIST=d12
[ -n "$IMAGENAME" ] || IMAGENAME=nulib/
COMPOSERDIR=.
COMPOSERPHAR=
VENDORDIR=vendor
BUILDENV0=
BUILDENV=
DIST="$RUNPHP_DIST"
IMAGENAME=nulib/
[ "$COMPOSERPHAR" == none ] && COMPOSERPHAR=
[ "$BUILDENV0" == none ] && BUILDENV0=
[ "$BUILDENV" == none ] && BUILDENV=
PRIVAREG=docker.io
REGISTRY="$RUNPHP_REGISTRY"
else
[ -n "$PROJDIR" ] || PROJDIR="$(dirname -- "$MYDIR")"
[ "${PROJDIR#/}" != "$PROJDIR" ] || PROJDIR="$(cd "$MYDIR/$PROJDIR"; pwd)"
[ -n "$COMPOSERDIR" ] || COMPOSERDIR=.
[ -n "$COMPOSERPHAR" ] || COMPOSERPHAR=sbin/composer.phar
[ -n "$VENDORDIR" ] || VENDORDIR=vendor
[ -n "$BUILDENV0" ] || BUILDENV0=.build.env.dist
[ -n "$BUILDENV" ] || BUILDENV=build.env
[ -n "$DIST" ] || DIST=d12
[ -n "$IMAGENAME" ] || IMAGENAME=nulib/
[ "$COMPOSERPHAR" == none ] && COMPOSERPHAR=
[ "$BUILDENV0" == none ] && BUILDENV0=
[ "$BUILDENV" == none ] && BUILDENV=
fi
function after_source_buildenv() {
NDIST="${DIST#d}"
@ -50,7 +66,7 @@ function is_defined() { [ -n "$(declare -p "$1" 2>/dev/null)" ]; }
function in_path() { [ -n "$1" -a -x "$(which "$1" 2>/dev/null)" ]; }
function composer() {
cd "$PROJDIR/$COMPOSERDIR" || exit 1
if [ -x "$PROJDIR/$COMPOSERPHAR" ]; then
if [ -n "$COMPOSERPHAR" -a -x "$PROJDIR/$COMPOSERPHAR" ]; then
"$PROJDIR/$COMPOSERPHAR" "$@"
elif in_path composer; then
command composer "$@"
@ -61,7 +77,7 @@ function composer() {
else
die "impossible de trouver composer"
fi
if [ -f composer.lock ]; then
if [ -z "$RUNPHP_STANDALONE" -a -f composer.lock ]; then
cp composer.lock "$PROJDIR/.composer.lock.runphp"
fi
}
@ -113,7 +129,7 @@ for arg in "$@"; do
done
set -- "${args[@]}"
if [ -z "$bootstrap" ]; then
if [ -z "$RUNPHP_STANDALONE" -a -z "$bootstrap" ]; then
# si vendor/ n'existe pas, alors on doit faire bootstrap
if [ ! -f "$PROJDIR/$VENDORDIR/nulib/php/load.sh" ]; then
ForcedBootstrap=1
@ -127,13 +143,13 @@ if [ -z "$bootstrap" ]; then
fi
if [ -n "$ForcedBootstrap" ]; then
[ -z "$_RUNPHP_IN_DOCKER" ] && eecho "== runphp is needed: bootstrapping"
[ "$RUNPHP_MODE" != docker ] && eecho "== runphp is needed: bootstrapping"
bootstrap=1
BootstrapOnly=
fi
fi
if [ -z "$_RUNPHP_IN_DOCKER" ]; then
if [ "$RUNPHP_MODE" != docker ]; then
############################################################################
# Lancement depuis l'extérieur du container
@ -196,8 +212,6 @@ if [ -z "$_RUNPHP_IN_DOCKER" ]; then
[ -n "$PRIVAREG" ] || PRIVAREG=
[ -n "$REGISTRY" ] || REGISTRY=pubdocker.univ-reunion.fr
## Construire l'image
if [ -n "$RUNPHP_NO_USE_RSLAVE" ]; then
UseRslave=
elif [ -n "$RUNPHP_USE_RSLAVE" ]; then
@ -229,6 +243,8 @@ if [ -z "$_RUNPHP_IN_DOCKER" ]; then
fi
if [ -n "$bootstrap" ]; then
## Mode bootstrap de l'image ###########################################
BUILD_ARGS=(
DIST NDIST
REGISTRY
@ -361,6 +377,8 @@ OPTIONS
[ -n "$BootstrapOnly" ] && exit 0
else
## Mode exécution de commande ##########################################
SOPTS=+w:v
LOPTS=help,chdir:,verbose,no-use-rslave
args="$(getopt -n "$MYNAME" -o "$SOPTS" -l "$LOPTS" -- "$@")" || exit 1; eval "set -- $args"
@ -414,7 +432,7 @@ OPTIONS
args=(
run -it --rm
--name "runphp-$(basename -- "$1")-$$"
-e _RUNPHP_IN_DOCKER=1
-e RUNPHP_MODE=docker
)
for arg in "${!PROXY_VARS[@]}"; do
args+=(--e "$arg=${PROXY_VARS[$arg]}")