début d'implémentation runphp standalone

bin/lib-runphp/runphp

@@ -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

bin/runphp

@@ -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" "$@"

bin_wip/runphp

@@ -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")"

runphp/build

@@ -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

runphp/dot-runphp.conf

@@ -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

runphp/runphp.2postamble

@@ -21,20 +21,36 @@ if [ -f "$MYDIR/runphp.userconf.local" ]; then
     source "$MYDIR/runphp.userconf.local"
 fi
 
-[ -n "$PROJDIR" ] || PROJDIR="$(dirname -- "$MYDIR")"
+if [ -n "$RUNPHP_STANDALONE" ]; then
-[ "${PROJDIR#/}" != "$PROJDIR" ] || PROJDIR="$(cd "$MYDIR/$PROJDIR"; pwd)"
+    PROJDIR="$RUNPHP_PROJDIR"
 
-[ -n "$COMPOSERDIR" ] || COMPOSERDIR=.
+    COMPOSERDIR=.
-[ -n "$COMPOSERPHAR" ] || COMPOSERPHAR=sbin/composer.phar
+    COMPOSERPHAR=
-[ -n "$VENDORDIR" ] || VENDORDIR=vendor
+    VENDORDIR=vendor
-[ -n "$BUILDENV0" ] || BUILDENV0=.build.env.dist
+    BUILDENV0=
-[ -n "$BUILDENV" ] || BUILDENV=build.env
+    BUILDENV=
-[ -n "$DIST" ] || DIST=d12
+    DIST="$RUNPHP_DIST"
-[ -n "$IMAGENAME" ] || IMAGENAME=nulib/
+    IMAGENAME=nulib/
 
-[ "$COMPOSERPHAR" == none ] && COMPOSERPHAR=
+    PRIVAREG=docker.io
-[ "$BUILDENV0" == none ] && BUILDENV0=
+    REGISTRY="$RUNPHP_REGISTRY"
-[ "$BUILDENV" == none ] && BUILDENV=
+
+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]}")