3252 lines
112 KiB
Bash
Executable File
3252 lines
112 KiB
Bash
Executable File
#!/bin/bash
|
|
# -*- coding: utf-8 mode: sh -*- vim:sw=4:sts=4:et:ai:si:sta:fenc=utf-8
|
|
source "$(dirname -- "$0")/lib/ulib/auto" || exit 1
|
|
urequire ptools xmlsupport
|
|
|
|
SELF="$script"
|
|
TEMPLATEDIR="$scriptdir/lib/dkbuild/templates"
|
|
|
|
[ -n "$COMPOSE_V1" ] && DOCKER_COMPOSE=(docker-compose) || DOCKER_COMPOSE=(docker compose)
|
|
|
|
function get_default_phpbuilder_image() {
|
|
echo "${REGISTRY:-pubdocker.univ-reunion.fr}/image/phpbuilder:${DIST:-d11}"
|
|
}
|
|
function get_default_javabuilder_image() {
|
|
echo "${REGISTRY:-pubdocker.univ-reunion.fr}/image/javabuilder:d11"
|
|
}
|
|
|
|
##~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
## Aide
|
|
|
|
function display_help() {
|
|
uecho "$scriptname: construire une image docker
|
|
|
|
USAGE
|
|
$scriptname action [options]
|
|
|
|
OPTIONS
|
|
--hdk, --help-dkbuild
|
|
Afficher l'aide sur le format du fichier dkbuild
|
|
--href, --help-reference
|
|
Afficher la référence sur les commandes utilisables dans un fichier
|
|
dkbuild
|
|
--compose-v1
|
|
Forcer l'utilisation de docker-compose v1
|
|
|
|
ACTIONS
|
|
|
|
$scriptname templates
|
|
lister les templates valides pour 'init --template'
|
|
|
|
$scriptname init [OPTIONS] [PROJDIR [NAME [GROUP]]]
|
|
initialiser un répertoire pour la construction d'une ou plusieurs images
|
|
docker, selon un modèle prédéfini
|
|
|
|
-j, --projdir PROJDIR
|
|
Spécifier le répertoire de projet à créer/mettre à jour. le répertoire
|
|
par défaut est le répertoire courant.
|
|
-t, --template TEMPLATE
|
|
Nom du modèle à utiliser. Utiliser 'default' par défaut
|
|
-v, --var VAR=VALUE
|
|
Spécifier une variable pour la génération des fichiers à partir du
|
|
modèle. Le nom de la variable est mis en majuscule avant remplacement
|
|
dans les fichiers
|
|
-n, --name NAME
|
|
-g, --group GROUP
|
|
Raccourcis pour respectivement -vname=NAME et -vgroup=GROUP
|
|
|
|
$scriptname build [OPTIONS] [BUILDVARS...]
|
|
construire les images. C'est l'action par défaut
|
|
|
|
Les arguments BUILDVARS de la forme ARG=VALUE permettent de spécifier des
|
|
arguments de build comme avec l'option --arg
|
|
|
|
-m, --machine MACHINE
|
|
Sélectionner la machine spécifiée avant de dérouler le script
|
|
-j, --projdir PROJDIR
|
|
Spécifier le répertoire de projet. Si cette option n'est pas spécifiée,
|
|
remonter la hiérarchie et prendre le premier répertoire qui contient un
|
|
fichier nommé dkbuild.
|
|
Si PROJDIR est un fichier, c'est ce fichier qui est utilisé comme script
|
|
de build. Le répertoire de projet sélectionné est le répertoire qui
|
|
contient le script de build.
|
|
Si le répertoire PROJDIR contient un fichier du même nom de base que le
|
|
fichier de build avec l'extension '.env' (i.e dkbuild.env par défaut),
|
|
ce fichier est lu de la même façon qu'un fichier de configuration
|
|
-c, --config CONFIG
|
|
Lire un fichier de configuration au format dkbuild. Si cette option
|
|
n'est pas spécifiée, les fichiers ~/.dkbuild.env et /etc/dkbuild.env
|
|
sont testés dans l'ordre et automatiquement sélectionnés s'ils existent.
|
|
L'ordre de priorité est le suivant:
|
|
- d'abord les variables spécifiées avec --env et --arg,
|
|
- puis les variables définies dans ce fichier de configuration,
|
|
- puis celles définies dans dkbuild.env le cas échéant
|
|
- puis celles définies dans le fichier de build courant.
|
|
Utiliser la valeur spéciale 'none' pour indiquer qu'aucun fichier de
|
|
configuration ne doit être chargé.
|
|
|
|
-d, --dist DIST
|
|
-0, --d10
|
|
-1, --d11
|
|
-2, --d12
|
|
-3, --d13
|
|
--r7, --rhel7
|
|
--r8, --rhel8
|
|
--r9, --rhel9
|
|
--o7, --oracle7
|
|
--o8, --oracle8
|
|
--o9, --oracle9
|
|
Ne faire le build que pour la distribution spécifiée. Par défaut, faire
|
|
le build pour toutes les distributions définies. Si la distribution
|
|
sélectionnée n'est pas valide pour ce build, elle est ignorée
|
|
|
|
-g, --profile PROFILE
|
|
-P, --prod
|
|
-T, --test
|
|
-E, --dtest
|
|
--devel
|
|
Spécifier le profil dans lequel construire l'image
|
|
--all-profiles
|
|
Construire l'image dans tous les profils définis
|
|
|
|
-e, --env VAR=VALUE
|
|
Spécifier la valeur d'une variable d'environnement. Cette valeur
|
|
remplace la valeur par défaut spécifiée dans le fichier de build.
|
|
--arg ARG=VALUE
|
|
Spécifier la valeur d'un argument de build. Cette valeur remplace la
|
|
valeur par défaut spécifiée dans le fichier de build.
|
|
|
|
-u, --clean-update
|
|
Avant de faire le build, faire un clean, suivi de git pull. C'est la
|
|
méthode préférée pour mettre à jour le dépôt s'il y a des fichiers
|
|
synchronisé avec la commande 'copy', parce que sinon les fichiers
|
|
sources (mis à jour par git pull) sont désynchronisés d'avec les
|
|
fichiers destination.
|
|
--clone-src-only
|
|
Ne faire que cloner les dépôts sources mentionnés avec la commande
|
|
'checkout'
|
|
--update-src-only
|
|
Ne faire que mettre à jour les dépôts sources mentionnés avec la
|
|
commande 'checkout'
|
|
--update-src
|
|
Avec la commande 'checkout', mettre à jour les dépôts avant de faire le
|
|
build. C'est la valeur par défaut.
|
|
--no-update-src
|
|
Ne pas mettre à jour les dépôts avant de faire le build. La commande
|
|
'checkout' devient un NOP si le dépôt existe déjà.
|
|
-w, --update-devel-src
|
|
Ne pas mettre à jour le dépôt, préférer la synchronisation depuis la
|
|
version de développement d'un dépôt
|
|
-s, --sync-src
|
|
Avec la commande 'copy', effectuer la mise à jour des fichiers. C'est la
|
|
valeur par défaut si on construit l'image
|
|
--no-sync-src
|
|
Ne pas mettre à jour les fichiers. La commande 'copy' devient un NOP si
|
|
le fichier destination existe.
|
|
-b, --build
|
|
Construire les images
|
|
--no-cache
|
|
Ne pas utiliser le cache lors du build
|
|
--plain-output
|
|
Afficher la sortie complète des containers lors du build
|
|
-U, --pull-image
|
|
Essayer de récupérer une version plus récente de l'image source
|
|
-p, --push-image
|
|
Pousser les images construites vers la registry
|
|
|
|
$scriptname clean [OPTIONS] [DIRS...]
|
|
nettoyer le projet des fichiers créés par 'copy gitignore=', en utilisant la
|
|
commande 'git clean -dX'
|
|
|
|
-j, --projdir PROJDIR
|
|
Spécifier le répertoire de projet
|
|
-X, --ignored
|
|
Utiliser l'option -X de git clean pour ne supprimer que les fichiers
|
|
ignorés par git. c'est l'option par défaut.
|
|
-x, --untracked
|
|
Utiliser l'option -x de git clean pour supprimer aussi les fichiers non
|
|
suivis.
|
|
-a, --all
|
|
Supprimer aussi les fichiers listés par 'git status --ignored'. Cela
|
|
permet de supprimer un maximum de fichiers qui ne font pas partie du
|
|
projet. Cette option implique --untracked
|
|
|
|
$scriptname composer DESTDIR [ACTION [PARAMS] [ARGS]]
|
|
lancer composer dans le répertoire spécifié
|
|
|
|
cf la documentation de la commande 'composer' pour la description des
|
|
paramètres
|
|
|
|
$scriptname mvn DESTDIR [ACTION [PARAMS] [ARGS]]
|
|
lancer maven dans le répertoire spécifié
|
|
|
|
cf la documentation de la commande 'mvn' pour la description des paramètres
|
|
|
|
$scriptname dump [OPTIONS]
|
|
afficher les valeurs des variables
|
|
|
|
Les options suivantes ont la même signification que pour l'action build:
|
|
--machine, --projdir, --config, --dist, --profile, --all-profiles, --env,
|
|
--arg"
|
|
}
|
|
|
|
function display_help_dkbuild() {
|
|
uecho "\
|
|
OPTIONS
|
|
--help Aide générale
|
|
* --hdk Aide sur le format du fichier dkbuild
|
|
--href Référence sur les commandes utilisables dans un fichier dkbuild
|
|
|
|
DKBUILD
|
|
=======
|
|
|
|
Un fichier dkbuild est un script shell utilisé pour construire une ou plusieurs
|
|
images docker.
|
|
|
|
A cause de l'implémentation utilisée pour les directives, le fichier doit être
|
|
parcouru (i.e exécuté) à de multiples reprises pour analyser les paramètres et
|
|
variables définis. il faut donc \"protéger\" les appels de scripts externes ou
|
|
de fonctions gourmandes avec les commandes 'run' et 'call' pour éviter que ces
|
|
commandes ne soient exécutées à plusieurs reprises.
|
|
|
|
Quand un fichier dkbuild est exécuté, le répertoire courant est toujours le
|
|
répertoire qui contient le fichier
|
|
|
|
## Distributions ###############################################################
|
|
|
|
Une distribution s'entend au sens de la distribution linux utilisée comme base
|
|
pour l'image construite. L'idée est de pouvoir construire des images similaires
|
|
qui ne diffèrent que par la version de base du système d'exploitation
|
|
|
|
Pour une même distribution, plusieurs versions d'une image peuvent être
|
|
construites. Une version est définie en ajoutant un préfixe à la distribution.
|
|
|
|
La commande 'setdists' permet de lister explicitement les distributions valides
|
|
(et les versions associées le cas échéant). Si la distribution sélectionnée par
|
|
l'utilisateur n'est pas dans la liste fournie, le script s'arrête sans erreur.
|
|
|
|
La première distribution listée est spéciale: c'est la distribution la plus
|
|
récente, celle qui reçoit le tag :latest
|
|
|
|
La distribution 'none' est spéciale aussi: elle n'est pas mentionnée dans les
|
|
tags automatiquement attribués aux images.
|
|
|
|
La commande 'dist' permet de tester si la distribution spécifiée en argument a
|
|
été sélectionnée par l'utilisateur. L'argument 'LATEST' permet de tester la
|
|
dernière distribution.
|
|
|
|
La commande 'version' permet de tester si la version spécifiée en argument a été
|
|
sélectionnée par l'utilisateur. On part du principe qu'une distribution a déjà
|
|
été testée au préalable avec 'dist'
|
|
|
|
Exemple:
|
|
setdists 3.0-d11 3.1-d11 d10 d9
|
|
if dist d11; then
|
|
if version 3.0; then
|
|
...
|
|
elif version 3.1; then
|
|
...
|
|
fi
|
|
elif dist d10; then
|
|
...
|
|
elif dist d9; then
|
|
...
|
|
fi
|
|
Dans une même distribution, les versions doivent être ordonnées de la plus
|
|
ancienne à la plus récente. ici, la version 3.1 est listée après la version 3.0
|
|
pour que l'image construite aie le tag :latest
|
|
|
|
Note: 'setdists' ne doit être utilisé qu'une seule fois. Les invocations
|
|
suivantes sont ignorées.
|
|
|
|
## Profils #####################################################################
|
|
|
|
Un profil correspond à l'environnement de destination de l'image: production,
|
|
test, développement.
|
|
|
|
La commande 'setprofiles' permet de lister explicitement les profils valides.
|
|
Si le profil sélectionné par l'utilisateur n'est pas dans la liste fournie, le
|
|
script s'arrête avec une erreur. Le premier profil listé est spécial: c'est le
|
|
profil par défaut.
|
|
|
|
La commande 'default_profile' permet de spécifier un profil par défaut à
|
|
utiliser, exactement comme s'il avait été spécifié avec l'option --profile.
|
|
Cette commande est particulièrement appropriée pour le fichier ~/.dkbuild.env
|
|
s'il s'agit de définir le profil à utiliser sur un hôte.
|
|
|
|
La commande 'profile' permet de tester si le profil spécifié en argument a été
|
|
sélectionné par l'utilisateur. L'argument 'DEFAULT' permet de tester le profil
|
|
par défaut.
|
|
|
|
Exemple:
|
|
setprofiles prod devel
|
|
if profile prod; then
|
|
...
|
|
elif profile devel; then
|
|
...
|
|
fi
|
|
|
|
Si le build est indépendant de la distribution, ou si la distribution est
|
|
utilisée sans version, alors il est possible de préfixer le profil d'une
|
|
version. Exemple:
|
|
setprofiles v1-prod v2-prod
|
|
if profile prod; then
|
|
if version v1; then
|
|
...
|
|
elif version v2; then
|
|
...
|
|
fi
|
|
fi
|
|
Dans un même profil, les versions doivent être ordonnées de la plus ancienne à
|
|
la plus récente.
|
|
|
|
Si les distributions sont utilisées avec des versions, alors c'est une erreur de
|
|
spécifier une version dans le profil
|
|
|
|
Note: 'setprofiles' et 'default_profile' ne peuvent être utilisés qu'une seule
|
|
fois. Les invocations suivantes sont ignorées.
|
|
|
|
## Versions ####################################################################
|
|
|
|
Si la version de l'image à construire n'est liée ni à la distribution, ni au
|
|
profil, il est possible de la spécifier avec la commande 'setversion'. La
|
|
version spécifiée avec 'setversion' est utilisée par défaut pour toutes les
|
|
images dont la version n'est pas spécifiée dans la distribution ou le profil.
|
|
|
|
La commande 'setversion' est évaluée en même temps que les commandes 'setenv',
|
|
ainsi il est possible d'utiliser la valeur d'une variable définie au préalable.
|
|
|
|
## Environnement ###############################################################
|
|
|
|
La commande 'machine' permet de tester si le build est fait sur la machine
|
|
spécifiée. Ce peut être la machine courante, ou la machine spécifiée avec
|
|
l'option --machine de la commande build
|
|
|
|
Exemple:
|
|
if machine host{1,2,3}-prod; then
|
|
setprofiles prod
|
|
elif machine host{1,2,3}-test; then
|
|
setprofiles test
|
|
else
|
|
setprofiles devel test prod
|
|
fi
|
|
|
|
Les variables sont de deux types: argument de build ou variable d'environnement
|
|
|
|
La commande 'setenv' permet de définir une variable d'environnement. La commande
|
|
'setarg' permet de définir un argument de build. Ces valeurs sont alors
|
|
automatiquement utilisées à l'endroit approprié.
|
|
|
|
Ces commandes acceptent une liste d'argument de la forme VAR[=VALUE]
|
|
|
|
Si la valeur n'est pas spécifiée (e.g 'setarg DESTDIR'), alors la variable doit
|
|
être définie dans l'environnement courant. Si la variable n'est pas définie dans
|
|
l'environnement, alors le script s'arrête avec une erreur.
|
|
|
|
Une fois qu'une variable est définie, il n'est plus possible de la modifier. Les
|
|
commandes alternatives 'resetenv' et 'resetarg' permettent de pallier cette
|
|
limitation.
|
|
|
|
## Valeurs par défaut ##########################################################
|
|
|
|
Toutes les commandes ont des arguments requis, mais aussi des arguments
|
|
facultatifs qui sont fournis sous la forme d'une liste d'éléments VAR=VALUE
|
|
|
|
La commande 'default' permet de spécifier les valeurs par défaut de ces
|
|
arguments. Exemple:
|
|
if profile prod; then
|
|
default composer mode=production
|
|
elif profile devel; then
|
|
default composer mode=development
|
|
fi
|
|
composer install path/to/project
|
|
|
|
Une fois qu'une valeur par défaut est définie, il n'est plus possible de la
|
|
modifier. La commande alternative 'resetdefault' permet de pallier cette
|
|
limitation.
|
|
|
|
Définir des valeurs par défaut pour la commande 'docker' impacte la commande
|
|
'build' et toutes les commandes qui utilisent docker, comme 'composer' ou 'mvn'
|
|
|
|
## Synchronisation de fichiers #################################################
|
|
|
|
On peut vouloir s'assurer de la présence de certains fichiers à certains
|
|
endroits.
|
|
|
|
La commande 'checkout URL DESTDIR' permet de s'assurer qu'un checkout du dépôt
|
|
spécifié existe dans le répertoire DESTDIR. La branche ou le commit à utiliser,
|
|
la source en mode développement, etc. peuvent être spécifiés par des arguments
|
|
facultatifs.
|
|
|
|
La commande 'copy SRC DEST' permet de s'assurer que SRC et DEST sont
|
|
synchronisés. Si possible, des liens physiques sont créés pour conserver
|
|
l'espace disque. Par défaut, les fichiers ne sont créés que s'ils n'existent
|
|
pas.
|
|
|
|
## Support Composer, Maven, commandes génériques ###############################
|
|
|
|
La commande 'composer install' permet d'installer les dépendances Composer d'un
|
|
projet
|
|
|
|
La commande 'mvn package' permet de construire un projet Java.
|
|
|
|
La commande 'run' permet de lancer une commande quelconque. La commande est
|
|
cherchée dans le PATH et exécutée avec son chemin complet. celà permet de lancer
|
|
des commandes comme 'mvn' ou 'composer' ou dont le nom correspond à une fonction
|
|
déjà définie.
|
|
|
|
La commande 'call' permet de lancer une commande quelconque. La différence avec
|
|
'run' est que la commande est lancée telle quelle, sans modifications. Si une
|
|
fonction est définie, elle sera utilisée en priorité.
|
|
|
|
Les commandes 'runb' et 'callb' sont comme 'run' et 'call' respectivement, mais
|
|
elles ne sont exécutées que si build est activé.
|
|
|
|
Si elles sont utilisées sans argument, les commandes 'composer', 'mvn', 'run' et
|
|
'call' retournent vrai si la commande doit être exécutée dans le contexte
|
|
courant. Celà permet d'implémenter des traitements complexes. Ainsi le script
|
|
suivant:
|
|
run cmd1
|
|
run cmd2
|
|
est équivalent à:
|
|
if run; then
|
|
cmd1
|
|
cmd2
|
|
fi
|
|
|
|
En phase d'analyse, ces commandes retournent faux, donc cmd1 et cmd2 ne seront
|
|
lancés qu'une seule fois lors de l'invocation de dkbuild. Cela signifie qu'il ne
|
|
faut pas utiliser des directives de définition de variables à l'intérieur. Par
|
|
exemple, le script suivant ne produit pas forcément l'effet escompté:
|
|
if run; then
|
|
setenv var=value
|
|
default
|
|
cmd args...
|
|
fi
|
|
|
|
Bien entendu, si on veut être sûr que des commandes externes soient lancées, on
|
|
peut toujours utiliser 'run' à l'intérieur, e.g
|
|
if composer; then
|
|
run extcmd
|
|
func
|
|
composer args...
|
|
fi
|
|
|
|
## Support Dockerfile et docker build ##########################################
|
|
|
|
La commande 'dockerfile OUTPUT' permet de construire de façon incrémentale et
|
|
dynamique un fichier Dockerfile. Toutes les commandes d'un fichier dockerfile
|
|
traditionnelles sont reconnues et elles doivent être spécifiées après la
|
|
commande 'dockerfile'.
|
|
|
|
La commande 'build' termine la construction du fichier Docker puis lance la
|
|
construction de l'image.
|
|
* arguments de build: les arguments de build définis dans le script sont passés
|
|
à docker pour la construction de l'image
|
|
* nom de l'image et tag: par défaut, la variable d'environnement IMAGE est
|
|
combinée le cas échéant avec DIST et VERSION pour déterminer les tags que
|
|
reçoit l'image construite.
|
|
|
|
La commande 'cbuild' lance le build de toutes les images mentionnées dans les
|
|
fichiers 'docker-compose.yml' et 'docker-compose.PROFILE.yml' le cas échéant
|
|
* variables d'environnement: les arguments de build définis sont inscrits dans
|
|
un fichier .env qui est utilisé ensuite par docker compose
|
|
|
|
Si aucune commande 'build' ou 'cbuild' ne figure dans le fichier, 'build' est
|
|
lancé automatiquement à la fin
|
|
|
|
## Autres commandes ############################################################
|
|
|
|
Il est possible d'organiser le script dans plusieurs fichiers qui sont inclus
|
|
avec la commande 'include'. Fonctionnellement, cela se passe comme si le contenu
|
|
du fichier inclus était inséré dans le script principal, à ceci près que le
|
|
répertoire courant devient temporairement celui du fichier inclus.
|
|
|
|
Exemple:
|
|
setdists d11 d10 d9
|
|
if dist d9; then
|
|
include d9/dkbuild
|
|
elif dist d10; then
|
|
include d10/dkbuild
|
|
elif dist d11; then
|
|
include d11/dkbuild
|
|
fi
|
|
|
|
La commande 'dkbuild' lance le build d'un répertoire destination. La différence
|
|
avec 'include' est que cela est fait dans un processus complètement différent,
|
|
comme si le build avait été lancé depuis la ligne de commande.
|
|
|
|
Les commandes 'section', 'note', 'info', 'debug' permettent d'afficher des
|
|
messages de différents niveaux
|
|
|
|
## Variables globales ##########################################################
|
|
|
|
PROJDIR est le chemin absolu du projet, dans lequel se trouve le fichier dkbuild
|
|
initial
|
|
|
|
La distribution actuellement sélectionnée se trouve dans la variable DIST. La
|
|
version actuellement sélectionnée se trouve dans la variable VERSION. Si la
|
|
commande 'setdists' n'est pas utilisée, alors ni DIST ni VERSION ne sont définis
|
|
|
|
Le profil actuellement sélectionné se trouve dans la variable PROFILE. La
|
|
version actuellement sélectionnée se trouve dans la variable VERSION (si les
|
|
distributions sont utilisées sans le support de la version). Si la commande
|
|
'setprofiles' n'est pas utilisée, alors ni PROFILE ni VERSION ne sont définis
|
|
|
|
IMAGE est le nom de l'image à construire. Si le nom de l'image contient le tag
|
|
(e.g IMAGE:TAG) alors le nom est utilisé tel quel. Sinon, DIST et VERSION sont
|
|
utilisés comme tags (i.e IMAGE:DIST et IMAGE:VERSION-DIST)"
|
|
}
|
|
|
|
function display_help_reference() {
|
|
uecho "\
|
|
OPTIONS
|
|
--help Aide générale
|
|
--hdk Aide sur le format du fichier dkbuild
|
|
* --href Référence sur les commandes utilisables dans un fichier dkbuild
|
|
|
|
REFERENCE
|
|
=========
|
|
|
|
## fonctions d'affichage
|
|
|
|
USAGE:
|
|
section TITLE
|
|
note MESSAGE
|
|
info MESSAGE
|
|
debug MESSAGE
|
|
|
|
## machine -- vérifier la machine courante
|
|
|
|
## setdists -- spécifier les distributions valides
|
|
|
|
## dist -- vérifier la distribution courante
|
|
|
|
## setprofiles -- spécifier les profils valides
|
|
|
|
## default_profile -- spécifier le profil à utiliser si aucun profil n'est sélectionné
|
|
|
|
## profile -- vérifier le profil courant
|
|
|
|
## setversion -- spécifier la version par défaut
|
|
|
|
USAGE: setversion VERSION
|
|
|
|
Les paramètres optionnels sont
|
|
* from-file=FILE
|
|
prendre la version depuis le fichier spécifié. les formats pom.xml et
|
|
VERSION.txt sont supportés
|
|
* from-repo=REPO
|
|
calculer la version depuis le dépôt git spécifié
|
|
* from-glob=GLOB
|
|
calculer la version depuis le chemin spécifié
|
|
* extract=REGEXP
|
|
à partir de la valeur calculée par l'un des paramètres from-*, matcher
|
|
l'expression régulière au format AWK, et prendre comme version la valeur de
|
|
l'expression \$1
|
|
Si from-glob est spécifié, la valeur par défaut de extract est calculée en
|
|
remplaçant '*' par '(.*)'
|
|
* add-prefix=PREFIX
|
|
Ajouter le préfixe spécifié à la version extraite
|
|
* add-suffix=SUFFIX
|
|
Ajouter le suffixe spécifié à la version extraite
|
|
|
|
## version -- vérifier la version courante
|
|
|
|
## setenv -- spécifier une variable d'environnement
|
|
|
|
## resetenv -- spécifier une variable d'environnement
|
|
|
|
## setarg -- spécifier une variable de build
|
|
|
|
## resetarg -- spécifier une variable de build
|
|
|
|
## default -- spécifier des arguments par défaut
|
|
|
|
## resetdefault -- spécifier des arguments par défaut
|
|
|
|
## checkout -- faire et vérifier checkout d'un dépôt git
|
|
|
|
USAGE: checkout URL [DESTDIR] [PARAMS]
|
|
|
|
Les paramètres optionnels sont
|
|
* checkout
|
|
mettre à jour dépôt. c'est la valeur par défaut. utiliser checkout= pour
|
|
désactiver la mise à jour du dépôt. utiliser checkout=devel pour synchroniser
|
|
depuis le répertoire de développement.
|
|
* origin=ORIGIN
|
|
spécifier l'origine. Par défaut, prendre 'origin'
|
|
* branch=BRANCH
|
|
spécifier la branche à utiliser dans l'origine spécifiée. La valeur par défaut
|
|
est 'master' si les profils ne sont pas utilisé. Si les profils sont utilisés,
|
|
la valeur par défaut est 'develop' pour les profils 'test' et 'devel', sinon
|
|
c'est 'master'.
|
|
Utiliser la syntaxe ^COMMIT pour ignorer l'origine et sélectionner un commit
|
|
en particulier.
|
|
* develdir=DIR
|
|
spécifier l'emplacement du répertoire de développement, utilisé avec
|
|
checkout=devel
|
|
* develtype=TYPE
|
|
spécifier le type de projet pour la synchronisation depuis le répertoire de
|
|
développement. certains projets, notamment les projets composer avec des
|
|
dépendances de type 'path', nécessitent une méthode de synchronisation
|
|
particulière. Si ce paramètre n'est pas spécifié, il est auto-détecté. Les
|
|
valeurs supportées sont:
|
|
* composer -- détecté de par la présence d'un fichier composer.json
|
|
* maven -- détecté de par la présence d'un fichier pom.xml
|
|
* none -- valeur par défaut: pas de type particulier
|
|
|
|
## copy -- synchroniser des fichiers
|
|
|
|
USAGE: copy SRC DEST [PARAMS]
|
|
|
|
Si SRC est un fichier, alors DEST doit être un chemin vers le fichier
|
|
destination. Si SRC est un répertoire, alors DEST doit être un chemin vers le
|
|
répertoire destination. On peut forcer à considérer SRC et/ou DEST comme un
|
|
répertoire en les suffixant de '/'
|
|
|
|
Par exemple:
|
|
* copy SRCDIR/ DESTDIR/
|
|
échoue si SRCDIR et/ou DESTDIR sont des fichiers
|
|
* les commandes suivantes sont équivalentes:
|
|
copy SRC DESTDIR/
|
|
copy SRC DESTDIR/SRCNAME
|
|
|
|
Les paramètres optionnels sont
|
|
* copy
|
|
synchroniser les fichiers. c'est la valeur par défaut. utiliser copy= pour
|
|
désactiver la synchronisation des fichiers.
|
|
* overwrite
|
|
autoriser l'écrasement des fichiers destination, ce qui permet de rendre la
|
|
destination identique à la source. par défaut, un fichier destination est
|
|
laissé en place, ce qui permet d'avoir le cas échéant des fichiers locaux
|
|
différents de la source.
|
|
* gitignore=BASEDIR
|
|
maintenir le fichier .gitignore de BASEDIR, qui doit être un répertoire parent
|
|
de DESTDIR. Les fichiers synchronisés sont rajouté le cas échéant dans
|
|
.gitignore, sauf si le répertoire qui les contient est déjà exclu.
|
|
NB: Un fichier n'est considéré pour l'ajout dans .gitignore que s'il a été
|
|
copié au préalable. Ainsi, un fichier déjà existant dans la destination ne
|
|
sera pas ajouté dans le fichier .gitignore si overwrite=
|
|
|
|
## genfile -- créer un fichier générique
|
|
|
|
USAGE: genfile OUTPUT [INPUT] [PARAMS]
|
|
|
|
Si le fichier INPUT est spécifié, il est utilisé pour créer le contenu initial
|
|
du fichier. Sinon, l'entrée standard *doit* être redirigée depuis un fichier, et
|
|
elle est lue pour générer le contenu initial du fichier à générer.
|
|
|
|
Les paramètres optionnels sont
|
|
* context=DIR
|
|
générer le fichier dans le répertoire spécifié
|
|
* sed=SCRIPT
|
|
script sed à appliquer au fichier
|
|
|
|
## dockerfile -- créer un fichier Dockerfile
|
|
|
|
USAGE: dockerfile [OUTPUT [INPUT]] [PARAMS]
|
|
|
|
Si le fichier INPUT est spécifié, il est utilisé pour créer le contenu initial
|
|
du fichier. Sinon, *si* l'entrée standard est redirigée depuis un fichier, elle
|
|
est lue pour générer le contenu initial du fichier.
|
|
|
|
Les paramètres optionnels sont
|
|
* context=DIR
|
|
générer le fichier dans le répertoire spécifié
|
|
* sed=SCRIPT
|
|
script sed à appliquer au fichier initial, construit à partir de l'entrée
|
|
standard. Le fichier n'est plus modifié par la suite.
|
|
|
|
## build -- construire une image avec docker
|
|
|
|
USAGE: build [PARAMS]
|
|
|
|
Les paramètres optionnels sont
|
|
* build
|
|
construire les images, c'est la valeur par défaut. utiliser build= pour
|
|
désactiver la construction.
|
|
* context=DIR
|
|
répertoire de contexte. cette valeur est en principe générée automatiquement
|
|
par la commande 'dockerfile'
|
|
* dockerfile=FILE
|
|
fichier de build à utiliser. cette valeur est en principe générée automatiquement
|
|
par la commande 'dockerfile'
|
|
* no-cache
|
|
ne pas utiliser le cache
|
|
* pull
|
|
forcer la mise à jour des images dépendantes
|
|
* host-mappings=MAPPINGS
|
|
définir des mappings d'hôte. si ce paramètre n'est pas spécifié, consulter
|
|
aussi la valeur par défaut 'docker host-mappings='
|
|
* set-tag=TAGS... ou set-tags=TAGS...
|
|
spécifier des tags à rajouter au nom de l'image, séparés par un espace. cette
|
|
liste remplace celle calculée automatiquement. ce paramètre est ignoré pour
|
|
les noms d'images comportant un tag.
|
|
Utiliser le tag spécial LATEST pour rajouter :latest si c'est approprié
|
|
* add-tag=TAGS... ou add-tags=TAGS...
|
|
spécifier des tags à rajouter à la liste calculée automatiquement, séparés par
|
|
un espace. ce paramètre est ignoré pour les noms d'images comportant un tag
|
|
* image=IMAGES... ou images=IMAGES...
|
|
liste de nom d'images, séparés par un espace. si les noms n'ont pas de tag, le
|
|
tag est construit à partir de DIST et VERSION sous la forme [VERSION-]DIST
|
|
* push
|
|
pousser les images vers le registry après les avoir construites
|
|
|
|
## cbuild -- construire une image avec docker compose
|
|
|
|
USAGE: cbuild [SERVICE] [PARAMS]
|
|
|
|
Les paramètres optionnels sont
|
|
* files=FILES...
|
|
spécifier les fichiers docker-compose à utiliser. Par défaut, prendre
|
|
docker-compose.yml et docker-compose.PROFILE.yml
|
|
* project-name=PROJECT_NAME
|
|
spécifier le nom du projet
|
|
* no-cache
|
|
ne pas utiliser le cache
|
|
* pull
|
|
forcer la mise à jour des images dépendantes
|
|
|
|
## include -- inclure un autre fichier dkbuild
|
|
|
|
## dkbuild -- lancer un builder externe
|
|
|
|
La commande dkbuild qui traite le script de build courant est lancée telle
|
|
quelle, avec la même syntaxe qu'en ligne de commande. L'intérêt de cette
|
|
commande est qu'on est assuré d'utiliser le même dkbuild que celui qui traite le
|
|
script de build courant.
|
|
|
|
## composer -- gérer projet composer
|
|
|
|
USAGE: composer DESTDIR [ACTION [PARAMS] [ARGS]]
|
|
|
|
La destination est obligatoire. Sans arguments, cette commande retourne
|
|
simplement vrai
|
|
|
|
Les actions valides sont
|
|
* install -- installer les dépendances. c'est l'action par défaut
|
|
* update -- mettre à jour les dépendances
|
|
* rshell -- lancer un shell root dans le répertoire du projet
|
|
* shell -- lancer un shell utilisateur dans le répertoire du projet
|
|
* none -- ne rien faire
|
|
|
|
L'action est exécutée sur DESTDIR. Juste avant de lancer l'action, le répertoire
|
|
courant est modifié pour être DESTDIR, ce qui permet d'utiliser des chemins
|
|
relatifs le cas échéant.
|
|
|
|
La commande 'rshell' lance un shell bash avec l'utilisateur root au lieu de
|
|
lancer la commande composer, ce qui permet de faire des opérations plus
|
|
complexes si le besoin s'en fait sentir. La commande alternative 'shell' lance
|
|
le shell avec le compte utilisateur. Ces commandes sont particulièrement utiles
|
|
si composer est paramétré pour être lancé dans un container
|
|
|
|
Les paramètres optionnels sont
|
|
* args=ARGS...
|
|
arguments à rajouter à la commande composer. La valeur par défaut dépend du
|
|
profil:
|
|
* prod: --no-dev -o
|
|
* test: --no-dev -o
|
|
* autres profils: (pas d'arguments)
|
|
* php=VERSION
|
|
version de PHP en dessous de laquelle image= est utilisé. En d'autres termes,
|
|
c'est la version minimum de PHP nécessaire pour faire tourner composer. L'idée
|
|
est que si la version de PHP installée est suffisante, il n'est pas nécessaire
|
|
de passer par une image docker.
|
|
Cette valeur doit être spécifiée avec le format de PHP_VERSION_ID i.e 70300
|
|
pour PHP 7.3
|
|
* Spécifier 'any' ou 'force' pour forcer l'utilisation de l'image docker.
|
|
* Spécifier 'none' ou 'system' pour lancer directement composer sans passer
|
|
par une image docker.
|
|
Si php n'est pas disponible dans le PATH, ce paramètre prend par défaut la
|
|
valeur 'force'
|
|
* php-max=VERSION
|
|
version de PHP à partir de laquelle image= est utilisé. En d'autres termes,
|
|
c'est la version maximum de PHP, à partir de laquelle il faut passer par une
|
|
image docker. L'idée est que si la version de PHP installée est trop récente,
|
|
ça peut poser problème avec le calcul des dépendances.
|
|
Cette valeur doit être spécifiée avec le format de PHP_VERSION_ID i.e 70300
|
|
pour PHP 7.3
|
|
Si la valeur n'est pas spécifiée ou vaut 'none', elle est ignorée.
|
|
* image=COMPOSER_IMAGE
|
|
image docker utilisée pour lancer composer. La valeur par défaut est la valeur
|
|
de la variable d'environnement \$COMPOSER_IMAGE
|
|
Spécifier 'none' pour lancer directement composer sans passer par une image
|
|
docker.
|
|
L'image spécifiée doit disposer de la commande 'su-exec' afin de pouvoir
|
|
lancer la commande avec l'utilisateur courant. Le répertoire \$HOME est monté
|
|
à l'intérieur du container et le script composer.phar du projet est utilisé le
|
|
cas échéant.
|
|
* machine=MACHINE
|
|
nom de la docker machine sur laquelle se connecter pour lancer l'image docker.
|
|
La valeur par défaut est -u, ce qui force l'utilisation de l'instance docker
|
|
locale. Spécifier 'current' pour ne pas modifier la valeur courante le cas
|
|
échéant
|
|
* host-mappings=MAPPINGS
|
|
définir des mappings d'hôte. si ce paramètre n'est pas spécifié, consulter
|
|
aussi la valeur par défaut 'docker host-mappings='
|
|
* composer=PATH/TO/COMPOSER
|
|
chemin vers l'exécutable composer. Par défaut, utiliser composer.phar s'il
|
|
existe dans le répertoire du projet. Sinon utiliser /usr/bin/composer
|
|
* setup=CMDS...
|
|
liste de commandes à lancer pour configurer le container. Un container ayant
|
|
pour base COMPOSER_IMAGE et nommé d'après le nom du projet est préparé et les
|
|
commandes spécifiées y sont lancées. Ce container est réutilisé à chaque fois.
|
|
Ce paramétrage est utilisé par exemple pour installer certains packages
|
|
nécessaire au projet.
|
|
* setup-image=SETUP_IMAGE
|
|
forcer le nom de l'image pour setup= (la valeur de project-name= est ignorée)
|
|
* project-name=PROJECT_NAME
|
|
si setup= est défini, nommer l'image sur la base de ce nom. par défaut, le nom
|
|
est calculé automatiquement
|
|
|
|
Si un fichier .composer.yaml existe dans le répertoire du projet, il est analysé
|
|
pour obtenir les valeurs par défaut des paramètres suivants:
|
|
* composer_php_min: valeur par défaut de php=
|
|
* composer_php_max: valeur par défaut de php-max=
|
|
* composer_registry: ET composer_image: valeur par défaut de image=
|
|
* composer_setup: valeur par défaut de setup=
|
|
* composer_setup_image: valeur par défaut de setup-image=
|
|
|
|
Sinon, si un fichier .composer.conf existe dans le répertoire du projet, il est
|
|
sourcé pour obtenir les valeurs par défaut des paramètres:
|
|
* COMPOSER_PHP -- valeur par défaut de php=
|
|
* COMPOSER_PHP_MAX -- valeur par défaut de php-max=
|
|
* COMPOSER_IMAGE -- valeur par défaut de image=
|
|
* COMPOSER_MACHINE -- valeur par défaut de machine=
|
|
* COMPOSER_CMD -- valeur par défaut de composer=
|
|
* COMPOSER_SETUP -- valeur par défaut de setup=
|
|
* COMPOSER_SETUP_IMAGE -- valeur par défaut de setup-image=
|
|
|
|
## mvn -- construire projet maven
|
|
|
|
USAGE: mvn DESTDIR [ACTION [PARAMS] [ARGS]]
|
|
|
|
Le répertoire de destination est obligatoire. Sans arguments, cette commande
|
|
retourne simplement vrai. L'action par défaut est 'package'
|
|
|
|
Les actions valides sont
|
|
* install -- lance mvn avec les commandes 'clean package install'
|
|
* package -- lance mvn avec les commandes 'clean package'
|
|
* package_only -- lance mvn avec uniquement la commande 'package'
|
|
* rshell -- lancer un shell root dans le répertoire du projet
|
|
* shell -- lancer un shell utilisateur dans le répertoire du projet
|
|
* java -- lancer java au lieu de lancer mvn. il est possible de spécifier la
|
|
version de java directement, e.g java7, java8, java11
|
|
|
|
L'action est exécutée sur DESTDIR. Juste avant de lancer l'action, le répertoire
|
|
courant est modifié pour être DESTDIR, ce qui permet d'utiliser des chemins
|
|
relatifs le cas échéant.
|
|
|
|
La commande 'rshell' lance un shell bash avec l'utilisateur root au lieu de
|
|
lancer la commande mvn, ce qui permet de faire des opérations plus complexes si
|
|
le besoin s'en fait sentir. La commande alternative 'shell' lance le shell avec
|
|
le compte utilisateur. Ces commandes sont particulièrement utiles si mvn est
|
|
paramétré pour être lancé dans un container
|
|
|
|
Les paramètres optionnels sont
|
|
* args=ARGS...
|
|
arguments à rajouter à la commande mvn
|
|
* java=VERSION
|
|
version de Java à sélectionner à l'intérieur de l'image docker
|
|
* Spécifier 'any' ou 'force' pour prendre la valeur par défaut
|
|
* Spécifier 'none' ou 'system' pour ne pas utiliser l'image docker
|
|
Si java ou mvn ne sont pas disponibles dans le PATH, ce paramètre prend par
|
|
défaut la valeur 'force'
|
|
* image=MAVEN_IMAGE
|
|
image docker utilisée pour lancer mvn. La valeur par défaut est la valeur
|
|
de la variable d'environnement \$MAVEN_IMAGE
|
|
Spécifier 'none' pour lancer directement mvn sans passer par une image
|
|
docker, même si java= est renseigné
|
|
L'image spécifiée doit disposer de la commande 'su-exec' afin de pouvoir
|
|
lancer la commande avec l'utilisateur courant. Le répertoire \$HOME est monté
|
|
à l'intérieur du container.
|
|
* machine=MACHINE
|
|
nom de la docker machine sur laquelle se connecter pour lancer l'image docker.
|
|
La valeur par défaut est -u, ce qui force l'utilisation de l'instance docker
|
|
locale. Spécifier 'current' pour ne pas modifier la valeur courante le cas
|
|
échéant
|
|
* host-mappings=MAPPINGS
|
|
définir des mappings d'hôte. si ce paramètre n'est pas spécifié, consulter
|
|
aussi la valeur par défaut 'docker host-mappings='
|
|
* mvn=PATH/TO/MVN
|
|
chemin vers l'exécutable mvn. Par défaut, utiliser la commande trouvée dans le
|
|
PATH
|
|
* setup=CMDS...
|
|
liste de commandes à lancer pour configurer le container. Un container ayant
|
|
pour base MAVEN_IMAGE et nommé d'après le nom du projet est préparé et les
|
|
commandes spécifiées y sont lancées. Ce container est réutilisé à chaque fois.
|
|
Ce paramétrage est utilisé par exemple pour installer certains packages
|
|
nécessaire au projet.
|
|
* setup-image=SETUP_IMAGE
|
|
forcer le nom de l'image pour setup= (la valeur de project-name= est ignorée)
|
|
* project-name=PROJECT_NAME
|
|
si setup= est défini, nommer l'image sur la base de ce nom. par défaut, le nom
|
|
est calculé automatiquement
|
|
|
|
Si un fichier .maven.conf existe dans le répertoire du projet, il est sourcé
|
|
pour obtenir les valeurs par défaut des paramètres:
|
|
* MAVEN_JAVA -- valeur par défaut de java=
|
|
* MAVEN_IMAGE -- valeur par défaut de image=
|
|
* MAVEN_MACHINE -- valeur par défaut de machine=
|
|
* MAVEN_CMD -- valeur par défaut de mvn=
|
|
* MAVEN_SETUP -- valeur par défaut de setup=
|
|
* MAVEN_SETUP_IMAGE -- valeur par défaut de setup-image=
|
|
|
|
## run -- lancer des commandes
|
|
|
|
## runb -- lancer des commandes
|
|
|
|
## call -- lancer des commandes ou des fonctions
|
|
|
|
## callb -- lancer des commandes ou des fonctions
|
|
"
|
|
}
|
|
|
|
##~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
## shared
|
|
|
|
declare -A PROTECTED_VARS=(
|
|
[PROTECTED_VARS]=1
|
|
[SELF]=1
|
|
[SHARED_LOCALS1]=1
|
|
[SHARED_ARGS1]=1
|
|
[SHARED_LOCALS2]=1
|
|
[SHARED_ARGS2]=1
|
|
[TFUNCTIONS]=1
|
|
[FFUNCTIONS]=1
|
|
[PROJDIR]=1
|
|
[DKBUILD]=1
|
|
[CONFIG]=1
|
|
[MACHINE]=1
|
|
[SETDISTS_DONE]=1
|
|
[SETDISTS]=1
|
|
[SETPROFILES_DONE]=1
|
|
[SETPROFILES]=1
|
|
[DEFAULT_PROFILE]=1
|
|
[SETVERSION_DONE]=1
|
|
[SETVERSION]=1
|
|
[AUTOBUILD]=1
|
|
[DISTS]=1
|
|
[PROFILES]=1
|
|
[_ENVIRON]=1
|
|
[ENVIRON]=1
|
|
[ARGS]=1
|
|
[DEFAULTS]=1
|
|
)
|
|
|
|
SHARED_LOCALS1="local PROJDIR DKBUILD CONFIG"
|
|
SHARED_ARGS1=(
|
|
-j:,--projdir: PROJDIR=
|
|
-c:,--config: CONFIG=
|
|
)
|
|
|
|
SHARED_LOCALS2="local DIST PROFILE ALL_PROFILES; local -a TMPENVIRON TMPARGS"
|
|
SHARED_ARGS2=(
|
|
-d:,--dist: DIST=
|
|
-0,--d10 DIST=d10
|
|
-1,--d11 DIST=d11
|
|
-2,--d12 DIST=d12
|
|
-3,--d13 DIST=d13
|
|
--r7,--rhel7 DIST=rhel7
|
|
--r8,--rhel8 DIST=rhel8
|
|
--r9,--rhel9 DIST=rhel9
|
|
--ol7,--oracle7 DIST=ol7
|
|
--ol8,--oracle8 DIST=ol8
|
|
--ol9,--oracle9 DIST=ol9
|
|
|
|
-g:,--profile: PROFILE=
|
|
-P,--prod PROFILE=prod
|
|
-T,--test PROFILE=test
|
|
-E,--dtest PROFILE=dtest
|
|
-J,--jclain PROFILE=jclain
|
|
--devel PROFILE=devel
|
|
--all-profiles ALL_PROFILES=1
|
|
|
|
-e:,--env: '$TMPENVIRON+=("$value_")'
|
|
--arg: '$TMPARGS+=("$value_")'
|
|
)
|
|
|
|
TFUNCTIONS=(
|
|
# dkbuild
|
|
section note info debug
|
|
setdists dist
|
|
setprofiles profile
|
|
default_profile
|
|
setversion version
|
|
setenv resetenv
|
|
setarg resetarg
|
|
default resetdefault
|
|
checkout
|
|
copy
|
|
genfile
|
|
dockerfile
|
|
build
|
|
cbuild
|
|
# dockerfile
|
|
FROM
|
|
RUN
|
|
CMD
|
|
LABEL
|
|
MAINTAINER
|
|
EXPOSE
|
|
ENV
|
|
ADD
|
|
COPY
|
|
ENTRYPOINT
|
|
VOLUME
|
|
USER
|
|
WORKDIR
|
|
ARG
|
|
ONBUILD
|
|
STOPSIGNAL
|
|
HEALTHCHECK
|
|
SHELL
|
|
)
|
|
FFUNCTIONS=(
|
|
# dkbuild
|
|
composer
|
|
mvn
|
|
run
|
|
runb
|
|
call
|
|
callb
|
|
dkbuild
|
|
)
|
|
|
|
function set_machine() {
|
|
local machine="$1"
|
|
if [ "$machine" == -u ]; then
|
|
# déselectionner la machine courante
|
|
local -x DOCKER_TLS_VERIFY= DOCKER_HOST= DOCKER_CERT_PATH= DOCKER_MACHINE_NAME=
|
|
machine=
|
|
fi
|
|
if [ -n "$machine" ]; then
|
|
if [ -f ~/etc/default/dk ]; then
|
|
machine="$(
|
|
CLUSTERDIRS=()
|
|
DM_ALIASES=()
|
|
source ~/etc/default/dk
|
|
for alias_machine in "${DM_ALIASES[@]}"; do
|
|
if [ "${alias_machine%%:*}" == "$machine" ]; then
|
|
echo "${alias_machine#*:}"
|
|
exit
|
|
fi
|
|
done
|
|
for clusterdir in "${CLUSTERDIRS[@]}"; do
|
|
if [ -f "$clusterdir/0config/configure.conf" ]; then
|
|
DM_ALIASES=()
|
|
source "$clusterdir/0config/configure.conf"
|
|
for alias_machine in "${DM_ALIASES[@]}"; do
|
|
if [ "${alias_machine%%:*}" == "$machine" ]; then
|
|
echo "${alias_machine#*:}"
|
|
exit
|
|
fi
|
|
done
|
|
fi
|
|
done
|
|
echo "$machine"
|
|
)"
|
|
fi
|
|
eval "$(docker-machine env "$machine" || echo false)" || die
|
|
else
|
|
machine="$DOCKER_MACHINE_NAME"
|
|
[ -n "$machine" ] || machine="${HOSTNAME%%.*}"
|
|
fi
|
|
MACHINE="$machine"
|
|
}
|
|
|
|
function get_project_name() {
|
|
local project_name
|
|
setx project_name=basename -- "$(pwd)"
|
|
if [ "${project_name%.service}" != "$project_name" ]; then project_name="${project_name%.service}"
|
|
elif [ "${project_name%.stack}" != "$project_name" ]; then project_name="${project_name%.stack}"
|
|
elif [ "${project_name%.network}" != "$project_name" ]; then project_name="${project_name%.network}"
|
|
fi
|
|
echo "$project_name"
|
|
}
|
|
|
|
function get_container_name() {
|
|
local container_name="${1//[^a-zA-Z0-9_-]/}"
|
|
[ -n "$PROFILE" ] && container_name="${container_name}_$PROFILE"
|
|
echo "$container_name"
|
|
}
|
|
|
|
function reset_functions() {
|
|
local func
|
|
for func in "${TFUNCTIONS[@]}"; do
|
|
eval "function $func() { : echo \"$func \$*\"; return 0; }"
|
|
done
|
|
for func in "${FFUNCTIONS[@]}"; do
|
|
eval "function $func() { : echo \"$func \$*\"; return 1; }"
|
|
done
|
|
function include() {
|
|
edebug "include $(qvals "$@")"
|
|
|
|
local file="$1" cwd="$(pwd)"
|
|
[ -d "$file" ] && file="$file/dkbuild"
|
|
[ -f "$file" ] || die "$file: fichier introuvable"
|
|
setx file=abspath "$file"
|
|
cd "$(dirname "$file")"
|
|
source "$file"
|
|
cd "$cwd"
|
|
}
|
|
function machine() {
|
|
local machine version
|
|
for machine in "$@"; do
|
|
[ "$machine" == "$MACHINE" ] && return
|
|
done
|
|
return 1
|
|
}
|
|
}
|
|
|
|
function _runcmd() {
|
|
edebug "\$ $(qvals "$@")"
|
|
"$@"
|
|
}
|
|
|
|
function ensure_projdir() {
|
|
if [ -z "$PROJDIR" ]; then
|
|
local found=
|
|
if [ ! -f dkbuild ]; then
|
|
# NB: on teste $PROJDIR != $scriptdir parce qu'il ne faut pas qu'on
|
|
# prenne le présent script comme un script de build...
|
|
PROJDIR="$(pwd)"
|
|
if [ "${PROJDIR#$HOME/}" != "$PROJDIR" ]; then
|
|
while [ "$PROJDIR" != "$HOME" ]; do
|
|
if [ -f "$PROJDIR/dkbuild" -a "$PROJDIR" != "$scriptdir" ]; then
|
|
found=1
|
|
break
|
|
fi
|
|
setx PROJDIR=dirname "$PROJDIR"
|
|
done
|
|
else
|
|
while [ "$PROJDIR" != / ]; do
|
|
if [ -f "$PROJDIR/dkbuild" -a "$PROJDIR" != "$scriptdir" ]; then
|
|
found=1
|
|
break
|
|
fi
|
|
setx PROJDIR=dirname "$PROJDIR"
|
|
done
|
|
fi
|
|
fi
|
|
if [ -n "$found" ]; then
|
|
enote "Sélection du répertoire de projet $(relpath "$PROJDIR")"
|
|
else
|
|
PROJDIR=.
|
|
fi
|
|
fi
|
|
|
|
if [ -f "$PROJDIR" ]; then
|
|
DKBUILD="$PROJDIR"
|
|
setx PROJDIR=dirname "$PROJDIR"
|
|
else
|
|
DKBUILD="$PROJDIR/dkbuild"
|
|
fi
|
|
[ -d "$PROJDIR" ] || die "$PROJDIR: répertoire de projet introuvable"
|
|
|
|
setx PROJDIR=abspath "$PROJDIR"
|
|
setx DKBUILD=abspath "$DKBUILD"
|
|
cd "$PROJDIR" || die
|
|
[ -f "$DKBUILD" ] || die "$(ppath "$DKBUILD"): fichier de build introuvable"
|
|
|
|
if [ "$CONFIG" == none ]; then
|
|
edebug "no default config used"
|
|
elif [ -n "$CONFIG" ]; then
|
|
setx CONFIG=abspath "$CONFIG"
|
|
edebug "using config $CONFIG"
|
|
else
|
|
local config
|
|
for config in ~/.dkbuild.env /etc/dkbuild.env; do
|
|
if [ -f "$config" ]; then
|
|
CONFIG="$config"
|
|
edebug "using default config $CONFIG"
|
|
break
|
|
fi
|
|
done
|
|
fi
|
|
}
|
|
|
|
function load_dkbuild() {
|
|
local dkbuildenv="$PROJDIR/$(basename "$DKBUILD").env"
|
|
cd "$PROJDIR"
|
|
if [ -n "$CONFIG" ]; then
|
|
edebug "loading $CONFIG"
|
|
source "$CONFIG"
|
|
fi
|
|
if [ -f "$dkbuildenv" ]; then
|
|
edebug "loading $dkbuildenv"
|
|
source "$dkbuildenv"
|
|
fi
|
|
edebug "loading $DKBUILD"
|
|
source "$DKBUILD"
|
|
}
|
|
|
|
function load_environ() {
|
|
declare -g -A _ENVIRON
|
|
eval "$(declare -p -x | sed -r 's/^declare -x ([^=]+)=/_ENVIRON[\1]=/')"
|
|
}
|
|
|
|
function from_glob() {
|
|
local var=value value
|
|
[[ "$1" != *=* ]] && { var="$1"; shift; }
|
|
|
|
local path extract add_prefix add_suffix
|
|
while [ $# -gt 0 ]; do
|
|
case "$1" in
|
|
path=*) path="${1#path=}";;
|
|
extract=*) extract="${1#extract=}";;
|
|
add-prefix=*) add_prefix="${1#add-prefix=}";;
|
|
add-suffix=*) add_suffix="${1#add-suffix=}";;
|
|
*=*) ewarn "path: $1: argument ignoré";;
|
|
*) break;;
|
|
esac
|
|
shift
|
|
done
|
|
value="$(list_all . "$path" | sort -rn | head -1)"
|
|
[ -n "$extract" ] || extract="${path//\*/(.*)}"
|
|
if [ -n "$extract" ]; then
|
|
extract="${extract//\//\\/}"
|
|
value="$add_prefix$(awk -v version="$value" "BEGIN {
|
|
if (match(version, /$extract/, vs)) { print vs[1] }
|
|
else { print version }
|
|
}")$add_suffix"
|
|
fi
|
|
|
|
local "$var"; upvar "$var" "$value"
|
|
}
|
|
function define_functions_env() {
|
|
function setversion() {
|
|
[ -n "$SETVERSION_DONE" ] && return
|
|
# sans argument, retourner 0
|
|
[ $# -eq 0 ] && return
|
|
|
|
local from_file from_repo from_glob extract add_prefix add_suffix
|
|
while [ $# -gt 0 ]; do
|
|
case "$1" in
|
|
from-file|file) from_file=.;;
|
|
from-file=*|file=*)
|
|
from_file="${1#from-}"; from_file="${from_file#file=}"
|
|
;;
|
|
from-repo|repo) from_repo=.;;
|
|
from-repo=*|repo=*)
|
|
from_repo="${1#from-}"; from_repo="${from_repo#repo=}"
|
|
;;
|
|
from-glob=*|glob=*)
|
|
from_glob="${1#from-}"; from_glob="${from_glob#glob=}"
|
|
;;
|
|
extract=*) extract="${1#extract=}";;
|
|
add-prefix=*) add_prefix="${1#add-prefix=}";;
|
|
add-suffix=*) add_suffix="${1#add-suffix=}";;
|
|
*=*) ewarn "setversion: $1: argument ignoré";;
|
|
*) break;;
|
|
esac
|
|
shift
|
|
done
|
|
if [ -n "$from_file" ]; then
|
|
if [ -d "$from_file" ]; then
|
|
setx SETVERSION=pver --sw "$from_file" || die
|
|
elif [[ "$from_file" == *.xml ]]; then
|
|
setx SETVERSION=pver -E "$from_file" || die
|
|
else
|
|
setx SETVERSION=pver -F "$from_file" || die
|
|
fi
|
|
elif [ -n "$from_repo" ]; then
|
|
die "setversion from-repo: pas encore implémenté" #XXX
|
|
elif [ -n "$from_glob" ]; then
|
|
SETVERSION="$(list_all . "$from_glob" | sort -rn | head -1)"
|
|
[ -n "$extract" ] || extract="${from_glob//\*/(.*)}"
|
|
else
|
|
SETVERSION="$1"
|
|
fi
|
|
if [ -n "$extract" ]; then
|
|
extract="${extract//\//\\/}"
|
|
SETVERSION="$add_prefix$(awk -v version="$SETVERSION" "BEGIN {
|
|
if (match(version, /$extract/, vs)) { print vs[1] }
|
|
else { print version }
|
|
}")$add_suffix"
|
|
fi
|
|
SETVERSION_DONE=1
|
|
}
|
|
function dist() {
|
|
local dist version latest
|
|
for dist in "$@"; do
|
|
if [ "$dist" == LATEST ]; then
|
|
latest=1
|
|
continue
|
|
fi
|
|
parse_dist "$dist" dist version
|
|
[ "$dist" == "$DIST" ] || continue
|
|
[ -z "$version" -o "$version" == "$DVERSION" ] || continue
|
|
return 0
|
|
done
|
|
if [ -n "$latest" ]; then
|
|
# trouver la dernière occurence de la première distribution
|
|
# mentionnée. en effet, les versions doivent être ordonnées de la
|
|
# plus ancienne à la plus récente.
|
|
local first_dist last_version
|
|
for dist in "${SETDISTS[@]}"; do
|
|
parse_dist "$dist" dist version
|
|
if [ -z "$first_dist" ]; then
|
|
first_dist="$dist"
|
|
last_version="$version"
|
|
elif [ "$dist" == "$first_dist" ]; then
|
|
last_version="$version"
|
|
fi
|
|
done
|
|
if [ "$first_dist" == "$DIST" ]; then
|
|
if [ -z "$last_version" -o "$last_version" == "$DVERSION" ]; then
|
|
return 0
|
|
fi
|
|
fi
|
|
fi
|
|
return 1
|
|
}
|
|
function version() {
|
|
local version
|
|
for version in "$@"; do
|
|
[ "$version" == "$VERSION" ] && return 0
|
|
done
|
|
return 1
|
|
}
|
|
function profile() {
|
|
local profile version default
|
|
for profile in "$@"; do
|
|
if [ "$profile" == DEFAULT ]; then
|
|
default=1
|
|
continue
|
|
fi
|
|
parse_profile "$profile" profile version
|
|
[ "$profile" == "$PROFILE" ] || continue
|
|
[ -z "$version" -o "$version" == "$PVERSION" ] || continue
|
|
return 0
|
|
done
|
|
if [ -n "$default" ]; then
|
|
# trouver la dernière occurence du premier profil mentionné. en
|
|
# effet, les versions doivent être ordonnées de la plus ancienne à
|
|
# la plus récente.
|
|
local first_profile last_version
|
|
for profile in "${SETPROFILES[@]}"; do
|
|
parse_profile "$profile" profile version
|
|
if [ -z "$first_profile" ]; then
|
|
first_profile="$profile"
|
|
last_version="$version"
|
|
elif [ "$profile" == "$first_profile" ]; then
|
|
last_version="$version"
|
|
fi
|
|
done
|
|
if [ "$first_profile" == "$PROFILE" ]; then
|
|
if [ -z "$last_version" -o "$last_version" == "$PVERSION" ]; then
|
|
return 0
|
|
fi
|
|
fi
|
|
fi
|
|
return 1
|
|
}
|
|
declare -g -A ENVIRON
|
|
function setenv() {
|
|
local name value
|
|
for name in "$@"; do
|
|
if [[ "$name" == *=* ]]; then
|
|
value="${name#*=}"
|
|
name="${name%%=*}"
|
|
else
|
|
value="${_ENVIRON[$name]-__UNDEFINED__}"
|
|
[ "$value" == __UNDEFINED__ ] && die "la variable d'environnement $name doit être définie"
|
|
fi
|
|
if [ "${ENVIRON[$name]-__UNDEFINED__}" == __UNDEFINED__ ]; then
|
|
# Ne spécifier la valeur que si elle n'a pas déjà été définie
|
|
_ENVIRON["$name"]="$value"
|
|
ENVIRON["$name"]="$value"
|
|
[ -z "${PROTECTED_VARS[$name]}" ] && _setv "export $name" "$value"
|
|
fi
|
|
done
|
|
}
|
|
function resetenv() {
|
|
local name value
|
|
for name in "$@"; do
|
|
if [[ "$name" == *=* ]]; then
|
|
value="${name#*=}"
|
|
name="${name%%=*}"
|
|
else
|
|
value="${_ENVIRON[$name]-__UNDEFINED__}"
|
|
[ "$value" == __UNDEFINED__ ] && die "la variable d'environnement $name doit être définie"
|
|
fi
|
|
_ENVIRON["$name"]="$value"
|
|
ENVIRON["$name"]="$value"
|
|
[ -z "${PROTECTED_VARS[$name]}" ] && _setv "export $name" "$value"
|
|
done
|
|
}
|
|
declare -g -A ARGS
|
|
function setarg() {
|
|
local name value
|
|
for name in "$@"; do
|
|
if [[ "$name" == *=* ]]; then
|
|
value="${name#*=}"
|
|
name="${name%%=*}"
|
|
else
|
|
value="${_ENVIRON[$name]-__UNDEFINED__}"
|
|
[ "$value" == __UNDEFINED__ ] && die "la variable d'environnement $name doit être définie"
|
|
fi
|
|
if [ "${ARGS[$name]-__UNDEFINED__}" == __UNDEFINED__ ]; then
|
|
# Ne spécifier la valeur que si elle n'a pas déjà été définie
|
|
ARGS["$name"]="$value"
|
|
fi
|
|
done
|
|
}
|
|
function resetarg() {
|
|
local name value
|
|
for name in "$@"; do
|
|
if [[ "$name" == *=* ]]; then
|
|
value="${name#*=}"
|
|
name="${name%%=*}"
|
|
else
|
|
value="${_ENVIRON[$name]-__UNDEFINED__}"
|
|
[ "$value" == __UNDEFINED__ ] && die "la variable d'environnement $name doit être définie"
|
|
fi
|
|
ARGS["$name"]="$value"
|
|
done
|
|
}
|
|
declare -g -A DEFAULTS
|
|
function default() {
|
|
local command="$1"; shift
|
|
local name value
|
|
for name in "$@"; do
|
|
if [[ "$name" == *=* ]]; then
|
|
value="${name#*=}"
|
|
name="${name%%=*}"
|
|
else
|
|
value=1
|
|
fi
|
|
name="${command}_$name"
|
|
if [ "${DEFAULTS[$name]-__UNDEFINED__}" == __UNDEFINED__ ]; then
|
|
# Ne spécifier la valeur que si elle n'a pas déjà été définie
|
|
DEFAULTS["$name"]="$value"
|
|
fi
|
|
done
|
|
}
|
|
function resetdefault() {
|
|
local command="$1"; shift
|
|
local name value
|
|
for name in "$@"; do
|
|
if [[ "$name" == *=* ]]; then
|
|
value="${name#*=}"
|
|
name="${name%%=*}"
|
|
else
|
|
value=1
|
|
fi
|
|
name="${command}_$name"
|
|
DEFAULTS["$name"]="$value"
|
|
done
|
|
}
|
|
}
|
|
|
|
function parse_dist() {
|
|
local dist="$1" version
|
|
if [[ "$dist" == *-* ]]; then
|
|
version="${dist%-*}"
|
|
dist="${dist##*-}"
|
|
fi
|
|
local "${2:-dist}"; upvar "${2:-dist}" "$dist"
|
|
local "${3:-version}"; upvar "${3:-version}" "$version"
|
|
}
|
|
|
|
function parse_profile() {
|
|
local profile="$1" version
|
|
if [[ "$profile" == *-* ]]; then
|
|
version="${profile%-*}"
|
|
profile="${profile##*-}"
|
|
fi
|
|
local "${2:-profile}"; upvar "${2:-profile}" "$profile"
|
|
local "${3:-version}"; upvar "${3:-version}" "$version"
|
|
}
|
|
|
|
function resolve_dists_profiles() {
|
|
## construire d'abord la liste des distributions et profils
|
|
edebug "Calcul de la liste des distributions et des profils"
|
|
reset_functions
|
|
SETDISTS_DONE=
|
|
SETDISTS=()
|
|
SETPROFILES_DONE=
|
|
SETPROFILES=()
|
|
DEFAULT_PROFILE=
|
|
SETVERSION_DONE=
|
|
SETVERSION=
|
|
AUTOBUILD=1
|
|
|
|
function setdists() {
|
|
[ -n "$SETDISTS_DONE" ] && return
|
|
SETDISTS=("$@")
|
|
SETDISTS_DONE=1
|
|
}
|
|
function setprofiles() {
|
|
[ -n "$SETPROFILES_DONE" ] && return
|
|
SETPROFILES=("$@")
|
|
SETPROFILES_DONE=1
|
|
}
|
|
function default_profile() {
|
|
[ -n "$DEFAULT_PROFILE" ] || DEFAULT_PROFILE="$1"
|
|
}
|
|
function build() {
|
|
AUTOBUILD=
|
|
}
|
|
function cbuild() {
|
|
AUTOBUILD=
|
|
}
|
|
load_dkbuild
|
|
|
|
if [ -z "$PROFILE" -a -z "$ALL_PROFILES" -a -n "$DEFAULT_PROFILE" ]; then
|
|
enote "Auto-sélection du profil $DEFAULT_PROFILE"
|
|
PROFILE="$DEFAULT_PROFILE"
|
|
fi
|
|
local MANUAL_SETPROFILES=
|
|
if [ -z "$SETPROFILES_DONE" -a -n "$PROFILE" ]; then
|
|
# Si l'utilisateur spécifie un profil mais qu'aucun profil n'a été
|
|
# défini dans la configuration, considérer que c'est cet unique profil
|
|
# qui a été défini
|
|
SETPROFILES=("$PROFILE")
|
|
SETPROFILES_DONE=1
|
|
MANUAL_SETPROFILES=1
|
|
fi
|
|
|
|
## ensuite vérifier si on est dans la bonne distribution
|
|
edebug "Calcul de la distribution courante"
|
|
reset_functions
|
|
DISTS=()
|
|
function setdists() {
|
|
local dist version found
|
|
# construire la liste des distributions à considérer
|
|
if [ -n "$DIST" ]; then
|
|
# on a spécifié une distribution en argument
|
|
for dist in "${SETDISTS[@]}"; do
|
|
if [ "$dist" == "$DIST" ]; then
|
|
# matcher avec la version éventuellement
|
|
found=1
|
|
break
|
|
fi
|
|
parse_dist "$dist"
|
|
if [ "$dist" == "$DIST" ]; then
|
|
# ou matcher uniquement la distribution
|
|
found=1
|
|
break
|
|
fi
|
|
done
|
|
# si aucune distribution ne correspond, arrêter le script
|
|
[ -n "$found" ] || exit 0
|
|
# forcer à ne construire que cette distribution
|
|
DISTS=("$DIST")
|
|
else
|
|
DISTS=("${SETDISTS[@]}")
|
|
fi
|
|
}
|
|
load_dkbuild
|
|
|
|
## puis vérifier si on est dans le bon profil
|
|
edebug "Calcul du profil courant"
|
|
reset_functions
|
|
PROFILES=()
|
|
function setprofiles() {
|
|
local profile version found
|
|
# construire la liste des distributions à considérer
|
|
if [ -n "$PROFILE" ]; then
|
|
# on a spécifié une distribution en argument
|
|
for profile in "${SETPROFILES[@]}"; do
|
|
if [ "$profile" == "$PROFILE" ]; then
|
|
# matcher avec la version éventuellement
|
|
found=1
|
|
break
|
|
fi
|
|
parse_profile "$profile"
|
|
if [ "$profile" == "$PROFILE" ]; then
|
|
# ou matcher uniquement le profil
|
|
found=1
|
|
break
|
|
fi
|
|
done
|
|
# si aucune distribution ne correspond, arrêter le script
|
|
[ -n "$found" ] || die "$PROFILE: profil invalide"
|
|
# forcer à ne construire que cette distribution
|
|
PROFILES=("$PROFILE")
|
|
elif [ -n "$ALL_PROFILES" ]; then
|
|
# prendre tous les profils comme indiqué
|
|
for profile in "${SETPROFILES[@]}"; do
|
|
parse_profile "$profile"
|
|
PROFILES+=("$profile")
|
|
done
|
|
else
|
|
# prendre le profil par défaut
|
|
parse_profile "${SETPROFILES[0]}"
|
|
PROFILES=("$profile")
|
|
fi
|
|
}
|
|
load_dkbuild
|
|
|
|
if [ -n "$MANUAL_SETPROFILES" ]; then
|
|
setprofiles "$PROFILE"
|
|
fi
|
|
|
|
## Si pas de distribution ou de profil, remplacer par valeur vide
|
|
if [ ${#DISTS[*]} -eq 0 ]; then
|
|
SETDISTS=("")
|
|
DISTS=("")
|
|
fi
|
|
if [ ${#PROFILES[*]} -eq 0 ]; then
|
|
SETPROFILES=("")
|
|
PROFILES=("")
|
|
fi
|
|
|
|
## puis calculer la version par défaut
|
|
edebug "Calcul de la version par défaut"
|
|
reset_functions
|
|
define_functions_env
|
|
load_dkbuild
|
|
}
|
|
|
|
function foreach_dists_profiles() {
|
|
local each="$1" before="$2" after="$3"
|
|
|
|
local version dist dversion profile pversion
|
|
local VERSION DIST DVERSION PROFILE PVERSION
|
|
local HAVE_VERSION LAST_VERSION
|
|
declare -A dones
|
|
|
|
if [ -n "$before" ]; then
|
|
"$before"
|
|
fi
|
|
for dist in "${DISTS[@]}"; do
|
|
parse_dist "$dist" dist dversion
|
|
# y a-t-il une version dans cette distribution ou ce profil, et si oui, laquelle?
|
|
HAVE_VERSION=
|
|
LAST_VERSION=
|
|
for DIST in "${SETDISTS[@]}"; do
|
|
parse_dist "$DIST" DIST DVERSION
|
|
[ "$DIST" == "$dist" ] || continue
|
|
VERSION="$DVERSION"
|
|
for profile in "${PROFILES[@]}"; do
|
|
parse_profile "$profile" profile pversion
|
|
for PROFILE in "${SETPROFILES[@]}"; do
|
|
parse_profile "$PROFILE" PROFILE PVERSION
|
|
[ "$PROFILE" == "$profile" ] || continue
|
|
[ -n "$DVERSION" ] && PVERSION= || VERSION="$PVERSION"
|
|
[ -z "$VERSION" -a -n "$SETVERSION" ] && VERSION="$SETVERSION"
|
|
if [ -n "$VERSION" ]; then
|
|
HAVE_VERSION=1
|
|
LAST_VERSION="$VERSION"
|
|
fi
|
|
done
|
|
done
|
|
done
|
|
|
|
for DIST in "${SETDISTS[@]}"; do
|
|
parse_dist "$DIST" DIST DVERSION
|
|
[ "$DIST" == "$dist" ] || continue
|
|
[ -z "$dversion" -o "$DVERSION" == "$dversion" ] || continue
|
|
VERSION="$DVERSION"
|
|
|
|
for profile in "${PROFILES[@]}"; do
|
|
parse_profile "$profile" profile pversion
|
|
for PROFILE in "${SETPROFILES[@]}"; do
|
|
parse_profile "$PROFILE" PROFILE PVERSION
|
|
[ "$PROFILE" == "$profile" ] || continue
|
|
if [ -z "$DVERSION" ]; then
|
|
[ -z "$pversion" -o "$PVERSION" == "$pversion" ] || continue
|
|
VERSION="$PVERSION"
|
|
else
|
|
PVERSION=
|
|
fi
|
|
|
|
[ -n "${dones[$PVERSION-$PROFILE-$DVERSION-$DIST]}" ] && continue
|
|
dones["$PVERSION-$PROFILE-$DVERSION-$DIST"]=1
|
|
|
|
[ -z "$VERSION" -a -n "$SETVERSION" ] && VERSION="$SETVERSION"
|
|
|
|
"$each"
|
|
done
|
|
done
|
|
done
|
|
done
|
|
if [ -n "$after" ]; then
|
|
"$after"
|
|
fi
|
|
}
|
|
|
|
function define_functions_cmd() {
|
|
_IN_SECTION=
|
|
function section() {
|
|
[ -n "$_IN_SECTION" ] && eend
|
|
etitle "$*"
|
|
_IN_SECTION=1
|
|
}
|
|
function note() {
|
|
enote "$*"
|
|
}
|
|
function info() {
|
|
estep "$*"
|
|
}
|
|
function debug() {
|
|
edebug "$*"
|
|
}
|
|
function checkout() {
|
|
edebug "checkout $(qvals "$@")"
|
|
|
|
local url destdir
|
|
[[ "$1" != *=* ]] && { url="$1"; shift; }
|
|
[[ "$1" != *=* ]] && { destdir="$1"; shift; }
|
|
|
|
local checkout="${DEFAULTS[checkout_checkout]-1}"
|
|
local origin="${DEFAULTS[checkout_origin]}"
|
|
local branch="${DEFAULTS[checkout_branch]}"
|
|
local develdir="${DEFAULTS[checkout_develdir]}"
|
|
local develtype="${DEFAULTS[checkout_develtype]}"
|
|
while [ $# -gt 0 ]; do
|
|
case "$1" in
|
|
checkout) checkout=1;;
|
|
checkout=*) checkout="${1#checkout=}";;
|
|
origin=*) origin="${1#origin=}";;
|
|
branch=*) branch="${1#branch=}";;
|
|
develdir=*) develdir="${1#develdir=}";;
|
|
develtype=*) develtype="${1#develtype=}";;
|
|
*) ewarn "checkout: $1: argument ignoré";;
|
|
esac
|
|
shift
|
|
done
|
|
|
|
[ -n "$checkout" ] || return
|
|
[ -n "$url" -a -n "$destdir" ] || die "checkout: Vous devez spécifier l'url du dépôt et la destination"
|
|
[ -n "$origin" ] || origin=origin
|
|
if [ -z "$branch" ]; then
|
|
case "$PROFILE" in
|
|
test|devel) branch=develop;;
|
|
*) branch=master;;
|
|
esac
|
|
fi
|
|
|
|
if [ "$checkout" == devel ]; then
|
|
# synchronisation depuis le répertoire de développement
|
|
[ -n "$develdir" ] || die "checkout: vous devez spécifier le répertoire de développement"
|
|
[ -d "$develdir" ] || die "checkout: répertoire de développement introuvable"
|
|
|
|
die "Pas encore implémenté" #XXX
|
|
|
|
elif [ -d "$destdir" -a -d "$destdir/.git" ]; then
|
|
# maj du dépôt
|
|
local cwd="$(pwd)"
|
|
|
|
estep "checkout: maj du dépôt $url --> $destdir (origin=$origin, branch=$branch)"
|
|
cd "$destdir"
|
|
git fetch --all -p -f || die
|
|
if [ "${branch#^}" != "$branch" ]; then
|
|
git reset --hard "${branch#^}" || die
|
|
else
|
|
git reset --hard "$origin/$branch" || die
|
|
fi
|
|
cd "$cwd"
|
|
|
|
else
|
|
# reliquat checkout=devel?
|
|
[ -d "$destdir" ] && rm -rf "$destdir"
|
|
|
|
# clone
|
|
estep "checkout: clone du dépôt $url --> $destdir (origin=$origin, branch=$branch)"
|
|
if [ "${BRANCH#^}" != "$BRANCH" ]; then
|
|
local cwd="$(pwd)"
|
|
git clone -o "$origin" "$url" "$destdir" || die
|
|
cd "$destdir"
|
|
git reset --hard "${branch#^}" || die
|
|
cd "$cwd"
|
|
else
|
|
git clone -o "$origin" -b "$branch" "$url" "$destdir" || die
|
|
fi
|
|
fi
|
|
}
|
|
function copy() {
|
|
edebug "copy $(qvals "$@")"
|
|
|
|
local src dest
|
|
[[ "$1" != *=* ]] && { src="$1"; shift; }
|
|
[[ "$1" != *=* ]] && { dest="$1"; shift; }
|
|
|
|
local copy="${DEFAULTS[copy_copy]-1}"
|
|
local overwrite="${DEFAULTS[copy_overwrite]}"
|
|
local gitignore="${DEFAULTS[copy_gitignore]}"
|
|
while [ $# -gt 0 ]; do
|
|
case "$1" in
|
|
copy) copy=1;;
|
|
copy=*) copy="${1#copy=}";;
|
|
overwrite) overwrite=1;;
|
|
overwrite=*) overwrite="${1#overwrite=}";;
|
|
gitignore=*) gitignore="${1#gitignore=}";;
|
|
*) ewarn "copy: $1: argument ignoré";;
|
|
esac
|
|
shift
|
|
done
|
|
|
|
[ -n "$copy" ] || return
|
|
[ -n "$src" -a -n "$dest" ] || die "copy: Vous devez spécifier la source et la destination de la copie"
|
|
[ -e "$src" ] || {
|
|
ewarn "copy: $src: fichier ou répertoire introuvables"
|
|
return 1
|
|
}
|
|
|
|
local srcdir destdir
|
|
if [ "${src%/}" != "$src" ]; then
|
|
[ -d "$src" ] || die "copy: $src: doit être un répertoire"
|
|
setx srcdir=abspath "$src"
|
|
src=
|
|
elif [ -d "$src" ]; then
|
|
setx srcdir=abspath "$src"
|
|
src=
|
|
else
|
|
setx src=abspath "$src"
|
|
fi
|
|
if [ "${dest%/}" != "$dest" ]; then
|
|
[ -f "$dest" ] && die "copy: $dest: doit être un répertoire"
|
|
setx destdir=abspath "$dest"
|
|
dest=
|
|
elif [ -d "$dest" ]; then
|
|
setx destdir=abspath "$dest"
|
|
dest=
|
|
elif [ -f "$dest" ]; then
|
|
[ -n "$srcdir" ] && die "copy: $dest: doit être un répertoire"
|
|
setx dest=abspath "$dest"
|
|
elif [ -n "$srcdir" ]; then
|
|
setx destdir=abspath "$dest"
|
|
dest=
|
|
else
|
|
setx dest=abspath "$dest"
|
|
fi
|
|
|
|
local -a srcs dests
|
|
if [ -n "$srcdir" -a -n "$destdir" ]; then
|
|
# copie de répertoire à répertoire
|
|
local destpath="$(relpath "$destdir" "$PROJDIR")"
|
|
[ -n "$destpath" ] || destpath=.
|
|
estep "copy $(relpath "$srcdir" "$PROJDIR")/ --> $destpath/"
|
|
|
|
array_from_lines srcs "$(find "$srcdir/" -type f -o -type l)"
|
|
for src in "${srcs[@]}"; do
|
|
dest="$destdir/${src#$srcdir/}"
|
|
if [ -n "$overwrite" -o ! -f "$dest" ]; then
|
|
mkdirof "$dest" || die
|
|
cp -dfl "$src" "$dest" || die
|
|
dests+=("$dest")
|
|
fi
|
|
done
|
|
|
|
elif [ -n "$src" ]; then
|
|
# transformer copie de fichier à répertoire en copie de fichier à fichier
|
|
[ -n "$dest" ] || dest="$destdir/$(basename "$src")"
|
|
|
|
if [ -n "$overwrite" -o ! -f "$dest" ]; then
|
|
# copie de fichier à fichier
|
|
estep "copy $(relpath "$src" "$PROJDIR") --> $(relpath "$dest" "$PROJDIR")"
|
|
mkdirof "$dest" || die
|
|
cp -fl "$src" "$dest" || die
|
|
|
|
setx destdir=dirname "$dest"
|
|
dests+=("$dest")
|
|
fi
|
|
|
|
else
|
|
# en réalité, on ne devrait jamais arriver ici
|
|
die "copy: impossible de copier un répertoire dans un fichier"
|
|
fi
|
|
|
|
if [ -n "$gitignore" ]; then
|
|
setx gitignore=abspath "$gitignore"
|
|
[ -d "$gitignore" ] && gitignore="$gitignore/.gitignore"
|
|
|
|
local basedir
|
|
setx basedir=dirname "$gitignore"
|
|
if [ "${destdir#$basedir/}" == "$destdir" -a "$destdir" != "$basedir" ]; then
|
|
ewarn "copy: gitignore ignoré parce que le répertoire n'est pas un parent de destdir"
|
|
else
|
|
[ -f "$gitignore" ] || { mkdir -p "$basedir"; touch "$gitignore"; }
|
|
|
|
declare -A ignored_dirs
|
|
local ignored_dir
|
|
for dest in "${dests[@]}"; do
|
|
dest="/${dest#$basedir/}"
|
|
if grep -q "^$dest\$" "$gitignore"; then
|
|
ignored=1
|
|
else
|
|
ignored=
|
|
setx ignored_dir=dirname "$dest"
|
|
while [ "$ignored_dir" != / ]; do
|
|
ignored="${ignored_dirs[$ignored_dir/]-compute}"
|
|
if [ "$ignored" == compute ]; then
|
|
grep -q "^$ignored_dir/\$" "$gitignore" && ignored=1 || ignored=
|
|
ignored_dirs["$ignored_dir/"]="$ignored"
|
|
fi
|
|
if [ -n "$ignored" ]; then
|
|
# un répertoire parent est déjà ignoré, on peut
|
|
# passer au fichier suivant
|
|
break
|
|
fi
|
|
setx ignored_dir=dirname "$ignored_dir"
|
|
done
|
|
fi
|
|
|
|
if [ -z "$ignored" ]; then
|
|
# le fichier n'est pas ignoré, ni directement, ni via un
|
|
# répertoire parent. il faut donc l'ajouter à .gitignore
|
|
echo "$dest" >>"$gitignore"
|
|
fi
|
|
done
|
|
fi
|
|
fi
|
|
}
|
|
function genfile() {
|
|
edebug "genfile $(qvals "$@")"
|
|
|
|
local output input
|
|
[[ "$1" != *=* ]] && { output="$1"; shift; }
|
|
[[ "$1" != *=* ]] && { input="$1"; shift; }
|
|
|
|
local context="${DEFAULTS[genfile_context]}"
|
|
local sed="${DEFAULTS[genfile_sed]}"
|
|
while [ $# -gt 0 ]; do
|
|
case "$1" in
|
|
context=*) context="${1#context=}";;
|
|
sed=*) sed="${1#sed=}";;
|
|
*) ewarn "genfile: $1: argument ignoré";;
|
|
esac
|
|
shift
|
|
done
|
|
|
|
[ -n "${DEFAULTS[build_build]-1}" ] || return 0
|
|
[ -n "$output" ] || die "genfile: Vous devez spécifier le fichier en sortie"
|
|
if [ -n "$context" ]; then
|
|
mkdir -p "$context" || die
|
|
output="$context/$output"
|
|
fi
|
|
|
|
if [ -n "$input" ]; then
|
|
cat "$input" >"$output" || die
|
|
elif ! tty -s; then
|
|
cat >"$output"
|
|
else
|
|
die "genfile: Vous devez spécifier une source pour le fichier $output"
|
|
fi
|
|
if [ -n "$sed" ]; then
|
|
sed -i "$sed" "$output"
|
|
fi
|
|
}
|
|
function dockerfile() {
|
|
edebug "dockerfile $(qvals "$@")"
|
|
|
|
local input
|
|
[[ "$1" != *=* ]] && { DOCKERFILE="$1"; shift; }
|
|
[[ "$1" != *=* ]] && { input="$1"; shift; }
|
|
|
|
local context="${DEFAULTS[dockerfile_context]}"
|
|
local sed="${DEFAULTS[dockerfile_sed]}"
|
|
while [ $# -gt 0 ]; do
|
|
case "$1" in
|
|
context=*) context="${1#context=}";;
|
|
sed=*) sed="${1#sed=}";;
|
|
*) ewarn "dockerfile: $1: argument ignoré";;
|
|
esac
|
|
shift
|
|
done
|
|
|
|
[ -n "${DEFAULTS[build_build]-1}" ] || return 0
|
|
[ -n "$DOCKERFILE" ] || DOCKERFILE=Dockerfile
|
|
DOCKERCONTEXT=.
|
|
if [ -n "$context" ]; then
|
|
mkdir -p "$context" || die
|
|
DOCKERCONTEXT="$context"
|
|
DOCKERFILE="$context/$DOCKERFILE"
|
|
fi
|
|
|
|
setx DOCKERFILE=abspath "$DOCKERFILE"
|
|
if [ -n "$input" ]; then
|
|
cat "$input" >"$DOCKERFILE" || die
|
|
elif ! tty -s; then
|
|
cat >"$DOCKERFILE" || die
|
|
else
|
|
echo "# -*- coding: utf-8 mode: dockerfile -*- vim:sw=4:sts=4:et:ai:si:sta:fenc=utf-8" >"$DOCKERFILE"
|
|
fi
|
|
if [ -n "$sed" ]; then
|
|
sed -i "$sed" "$DOCKERFILE"
|
|
fi
|
|
}
|
|
function add2dockerfile() {
|
|
edebug "$(qvals "$@")"
|
|
|
|
[ -n "${DEFAULTS[build_build]-1}" ] || return 0
|
|
[ -n "$DOCKERFILE" ] || return
|
|
echo "$*" >>"$DOCKERFILE"
|
|
}
|
|
function FROM() { add2dockerfile FROM "$@"; }
|
|
function RUN() { add2dockerfile RUN "$@"; }
|
|
function CMD() { add2dockerfile CMD "$@"; }
|
|
function LABEL() { add2dockerfile LABEL "$@"; }
|
|
function MAINTAINER() { add2dockerfile MAINTAINER "$@"; }
|
|
function EXPOSE() { add2dockerfile EXPOSE "$@"; }
|
|
function ENV() { add2dockerfile ENV "$@"; }
|
|
function ADD() { add2dockerfile ADD "$@"; }
|
|
function COPY() { add2dockerfile COPY "$@"; }
|
|
function ENTRYPOINT() { add2dockerfile ENTRYPOINT "$@"; }
|
|
function VOLUME() { add2dockerfile VOLUME "$@"; }
|
|
function USER() { add2dockerfile USER "$@"; }
|
|
function WORKDIR() { add2dockerfile WORKDIR "$@"; }
|
|
function ARG() { add2dockerfile ARG "$@"; }
|
|
function ONBUILD() { add2dockerfile ONBUILD "$@"; }
|
|
function STOPSIGNAL() { add2dockerfile STOPSIGNAL "$@"; }
|
|
function HEALTHCHECK() { add2dockerfile HEALTHCHECK "$@"; }
|
|
function SHELL() { add2dockerfile SHELL "$@"; }
|
|
function build() {
|
|
edebug "build $(qvals "$@")"
|
|
|
|
local build="${DEFAULTS[build_build]-1}"
|
|
local no_cache="${DEFAULTS[build_no-cache]}"
|
|
local pull="${DEFAULTS[build_pull]}"
|
|
local host_mappings="${DEFAULTS[build_host-mappings]-__UNDEFINED__}"
|
|
[ "$host_mappings" == __UNDEFINED__ ] && host_mappings="${DEFAULTS[docker_host-mappings]}"
|
|
local set_tags="${DEFAULTS[build_set-tags]}"
|
|
local add_tags="${DEFAULTS[build_add-tags]}"
|
|
local images="${DEFAULTS[build_images]}"
|
|
local push="${DEFAULTS[build_push]}"
|
|
while [ $# -gt 0 ]; do
|
|
case "$1" in
|
|
build) build=1;;
|
|
build=*) build="${1#build=}";;
|
|
context=*) DOCKERCONTEXT="${1#context=}";;
|
|
dockerfile=*) DOCKERFILE="${1#dockerfile=}";;
|
|
no-cache) no_cache=1;;
|
|
no-cache=*) no_cache="${1#no-cache=}";;
|
|
pull) pull=1;;
|
|
pull=*) pull="${1#pull=}";;
|
|
host-mappings=*) host_mappings="${1#host-mappings=}";;
|
|
set-tag=*) set_tags="${1#set-tag=}";;
|
|
set-tags=*) set_tags="${1#set-tags=}";;
|
|
add-tag=*) add_tags="${1#add-tag=}";;
|
|
add-tags=*) add_tags="${1#add-tags=}";;
|
|
image=*) images="${1#image=}";;
|
|
images=*) images="${1#images=}";;
|
|
push) push=1;;
|
|
push=*) push="${1#push=}";;
|
|
*) ewarn "build: $1: argument ignoré";;
|
|
esac
|
|
shift
|
|
done
|
|
|
|
estep "build options:" ${build:+build} ${no_cache:+no-cache} ${pull:+pull} ${push:+push}
|
|
|
|
[ -n "$images" ] || images="$IMAGE"
|
|
eval "set_tags=($set_tags)"
|
|
eval "add_tags=($add_tags)"
|
|
eval "images=($images)"
|
|
local tag imagetag autotag=1
|
|
local -a imagetags
|
|
if [ ${#set_tags[*]} -gt 0 ]; then
|
|
autotag=
|
|
for imagetag in "${images[@]}"; do
|
|
if [[ "$imagetag" == *:* ]]; then
|
|
# le tag est déjà spécifié
|
|
imagetags+=("$imagetag")
|
|
else
|
|
for tag in "${set_tags[@]}" "${add_tags[@]}"; do
|
|
if [ "$tag" == LATEST ]; then
|
|
if [ -n "$HAVE_VERSION" -a "$VERSION" == "$LAST_VERSION" ]; then
|
|
tag=latest
|
|
else
|
|
# ignorer le tag LATEST s'il n'est pas applicable
|
|
continue
|
|
fi
|
|
fi
|
|
imagetags+=("$imagetag:$tag")
|
|
done
|
|
fi
|
|
done
|
|
else
|
|
for imagetag in "${images[@]}"; do
|
|
if [[ "$imagetag" == *:* ]]; then
|
|
# le tag est déjà spécifié
|
|
autotag=
|
|
imagetags+=("$imagetag")
|
|
else
|
|
for tag in "${add_tags[@]}"; do
|
|
if [ "$tag" == LATEST ]; then
|
|
# toujours ignorer le tag LATEST dans add_tags
|
|
continue
|
|
fi
|
|
imagetags+=("$imagetag:$tag")
|
|
done
|
|
[ -n "$VERSION" ] && imagetags+=("$imagetag:$VERSION-$DIST")
|
|
if [ -n "$DIST" -a "$DIST" != none -a -z "$HAVE_VERSION" ]; then
|
|
imagetags+=("$imagetag:$DIST")
|
|
fi
|
|
fi
|
|
done
|
|
fi
|
|
if [ -n "$autotag" ]; then
|
|
if [ -n "$DIST" ]; then
|
|
if [ -z "$HAVE_VERSION" ]; then
|
|
dist LATEST && imagetags+=("$imagetag:latest")
|
|
elif [ "$VERSION" == "$LAST_VERSION" ]; then
|
|
[ "$DIST" != none ] && imagetags+=("$imagetag:$DIST")
|
|
dist LATEST && imagetags+=("$imagetag:latest")
|
|
fi
|
|
elif [ -n "$PROFILE" ]; then
|
|
profile DEFAULT && imagetags+=("$imagetag:latest")
|
|
else
|
|
imagetags+=("$imagetag:latest")
|
|
fi
|
|
fi
|
|
|
|
local avar
|
|
local -a args; args=(
|
|
${no_cache:+--no-cache}
|
|
${progress:+--progress "$progress"}
|
|
${pull:+--pull}
|
|
)
|
|
eval "host_mappings=($host_mappings)"
|
|
for host_mapping in "${host_mappings[@]}"; do
|
|
args+=(--add-host "$host_mapping")
|
|
done
|
|
for avar in "${!ARGS[@]}"; do
|
|
args+=(--build-arg "$avar=${ARGS[$avar]}")
|
|
done
|
|
for imagetag in "${imagetags[@]}"; do
|
|
args+=(-t "$imagetag")
|
|
estep "tag $imagetag"
|
|
done
|
|
|
|
[ -n "$DOCKERCONTEXT" ] || DOCKERCONTEXT="${DEFAULTS[build_context]:-.}"
|
|
[ -n "$DOCKERFILE" ] || DOCKERFILE="${DEFAULTS[build_dockerfile]:-Dockerfile}"
|
|
if [ -n "$build" ]; then
|
|
etitle build
|
|
_runcmd docker build "${args[@]}" -f "$DOCKERFILE" "$DOCKERCONTEXT" || die
|
|
eend
|
|
fi
|
|
|
|
if [ -n "$push" ]; then
|
|
etitle push
|
|
for imagetag in "${imagetags[@]}"; do
|
|
_runcmd docker push "$imagetag" || die
|
|
done
|
|
eend
|
|
fi
|
|
|
|
DOCKERCONTEXT=
|
|
DOCKERFILE=
|
|
[ -n "$build" -o -n "$push" ]
|
|
}
|
|
function cbuild() {
|
|
edebug "cbuild $(qvals "$@")"
|
|
|
|
local build="${DEFAULTS[build_build]-1}"
|
|
local files="${DEFAULTS[cbuild_files]}"
|
|
local project_name="${DEFAULTS[cbuild_project-name]}"
|
|
local no_cache="${DEFAULTS[cbuild_no-cache]}"
|
|
local pull="${DEFAULTS[cbuild_pull]}"
|
|
while [ $# -gt 0 ]; do
|
|
case "$1" in
|
|
files=*) files="${1#files=}";;
|
|
project-name=*) project_name="${1#project-name=}";;
|
|
no-cache) no_cache=1;;
|
|
no-cache=*) no_cache="${1#no-cache=}";;
|
|
pull) pull=1;;
|
|
pull=*) pull="${1#pull=}";;
|
|
*=*) ewarn "cbuild: $1: argument ignoré";;
|
|
*) break;;
|
|
esac
|
|
shift
|
|
done
|
|
|
|
[ -n "$build" ] || return
|
|
if [ -n "$files" ]; then
|
|
eval "files=($files)"
|
|
else
|
|
files=(docker-compose.yml)
|
|
if [ -f "docker-compose.override.yml" ]; then
|
|
files+=("docker-compose.override.yml")
|
|
fi
|
|
if [ -n "$PROFILE" -a -f "docker-compose.$PROFILE.yml" ]; then
|
|
files+=("docker-compose.$PROFILE.yml")
|
|
fi
|
|
fi
|
|
[ -n "$project_name" ] || setx project_name=get_project_name
|
|
|
|
estep "cbuild files:" ${files[@]}
|
|
estep "cbuild options:" project_name="$project_name" ${no_cache:+no-cache} ${pull:+pull}
|
|
|
|
local file; local -a args
|
|
args=(
|
|
-p "$project_name"
|
|
)
|
|
for file in "${files[@]}"; do
|
|
args+=(-f "$file")
|
|
done
|
|
local avar evar; local -a bargs
|
|
bargs=(
|
|
${no_cache:+--no-cache}
|
|
${progress:+--progress "$progress"}
|
|
${pull:+--pull}
|
|
)
|
|
for avar in "${!ARGS[@]}"; do
|
|
bargs+=(--build-arg "$avar=${ARGS[$avar]}")
|
|
done
|
|
|
|
if [ -f .shared_env -o -f ".${MACHINE}_env" -o ${#ENVIRON[*]} -gt 0 ]; then
|
|
echo >.env "## fichier auto-généré. ne pas modifier ##"
|
|
fi
|
|
[ -f .shared_env ] && cat .shared_env >>.env
|
|
[ -f ".${MACHINE}_env" ] && cat ".${MACHINE}_env" >>.env
|
|
for evar in "${!ENVIRON[@]}"; do
|
|
echo_setv "$evar=${ENVIRON[$evar]}" >>.env
|
|
done
|
|
|
|
_runcmd "${DOCKER_COMPOSE[@]}" "${args[@]}" build "${bargs[@]}" "$@" || die
|
|
}
|
|
function _local_composer() {
|
|
case "$action" in
|
|
rootshell|rshell|rootbash|rbash)
|
|
shift
|
|
estep "Lancement d'un shell root"
|
|
sudo bash "$@"
|
|
return $?
|
|
;;
|
|
usershell|shell|userbash|bash)
|
|
shift
|
|
estep "Lancement d'un shell utilisateur"
|
|
bash "$@"
|
|
return $?
|
|
;;
|
|
*)
|
|
estep "composer $action"
|
|
if [ -n "$composer" ]; then :
|
|
elif [ -x composer.phar ]; then composer=./composer.phar
|
|
elif [ -x /usr/bin/composer ]; then composer=/usr/bin/composer
|
|
else die "Impossible de trouver composer"
|
|
fi
|
|
"$composer" "$action" $args "$@"
|
|
esac
|
|
}
|
|
function _docker_composer() {
|
|
local user group projdir actualcmd
|
|
setx user=id -un; setx user=getent passwd "$user"
|
|
setx group=id -gn; setx group=getent group "$group"
|
|
setx projdir=pwd
|
|
case "$action" in
|
|
rootshell|rshell|rootbash|rbash)
|
|
action=rshell
|
|
shift
|
|
actualcmd='eval "bash $args"'
|
|
;;
|
|
usershell|shell|userbash|bash)
|
|
action=shell
|
|
shift
|
|
actualcmd='eval "su-exec \"$user\" bash $args"'
|
|
;;
|
|
*)
|
|
actualcmd='eval "su-exec \"$user\" \"$composer\" $args"'
|
|
args="$action${args:+ $args}"
|
|
;;
|
|
esac
|
|
setx args=qvals $args "$@"
|
|
|
|
local -a basecmd setupscript runscript cmd
|
|
basecmd=(
|
|
-e user="$user"
|
|
-e group="$group"
|
|
-e projdir="$projdir"
|
|
-e setup="$setup"
|
|
-e setup_image="$setup_image"
|
|
-e composer="$composer"
|
|
-e args="$args"
|
|
)
|
|
eval "host_mappings=($host_mappings)"
|
|
for host_mapping in "${host_mappings[@]}"; do
|
|
basecmd+=(--add-host "$host_mapping")
|
|
done
|
|
basecmd+=(-v "$HOME:$HOME")
|
|
if [ "${projdir#$HOME/}" == "$projdir" ]; then
|
|
# si le répertoire de projet ne se trouve pas dans $HOME, le monter aussi
|
|
cmd+=(-v "$projdir:$projdir")
|
|
fi
|
|
setupscript='eval "$setup"'
|
|
runscript='
|
|
echo "$user" >>/etc/passwd; user="${user%%:*}"
|
|
echo "$group" >>/etc/group; group="${group%%:*}"
|
|
|
|
cd "$projdir"
|
|
if [ -n "$composer" ]; then :
|
|
elif [ -x composer.phar ]; then composer=./composer.phar
|
|
elif [ -x /usr/bin/composer ]; then composer=/usr/bin/composer
|
|
else
|
|
echo "ERROR: Impossible de trouver composer"
|
|
exit 1
|
|
fi
|
|
'"$actualcmd"
|
|
|
|
if [ -n "$setup" ]; then
|
|
local project_name container_name ctid
|
|
local setup_image="$setup_image"
|
|
|
|
# lancement dans un container docker à préparer
|
|
[ -n "$project_name" ] || setx project_name=get_project_name
|
|
setx container_name=get_container_name "$project_name"
|
|
[ -n "$setup_image" ] || setup_image="dkbuild_composer_${container_name}_image"
|
|
|
|
# vérifier l'existence de l'image
|
|
setx ctid=docker image ls --format '{{.ID}}' "$setup_image"
|
|
|
|
# créer le container le cas échéant
|
|
if [ -z "$ctid" ]; then
|
|
estep "Création de l'image $setup_image à partir de $image"
|
|
cmd=(
|
|
docker create -it --name "${setup_image}_tmpct"
|
|
"${basecmd[@]}"
|
|
"$image"
|
|
bash -c "$setupscript"
|
|
)
|
|
setx ctid="${cmd[@]}" &&
|
|
docker container start -ai "$ctid" &&
|
|
docker container commit "$ctid" "$setup_image" &&
|
|
docker container rm "$ctid" || die
|
|
fi
|
|
|
|
# prendre comme image le container créé
|
|
image="$setup_image"
|
|
fi
|
|
|
|
case "$action" in
|
|
rshell) estep "Lancement d'un shell root (avec l'image $image)";;
|
|
shell) estep "Lancement d'un shell utilisateur (avec l'image $image)";;
|
|
*) estep "composer $action (avec l'image $image)";;
|
|
esac
|
|
cmd=(
|
|
docker run -it --rm
|
|
"${basecmd[@]}"
|
|
"$image"
|
|
bash -c "$runscript"
|
|
)
|
|
"${cmd[@]}"
|
|
}
|
|
function composer() {
|
|
edebug "composer $(qvals "$@")"
|
|
[ $# -eq 0 ] && return 0
|
|
|
|
local action destdir
|
|
[[ "$1" != *=* ]] && { destdir="$1"; shift; }
|
|
[[ "$1" != *=* ]] && { action="$1"; shift; }
|
|
|
|
[ -n "$destdir" ] || destdir=.
|
|
[ -d "$destdir" ] || die "composer: $destdir: répertoire introuvable"
|
|
local cwd="$(pwd)"
|
|
cd "$destdir" || die
|
|
|
|
[ -n "$action" ] || action=install
|
|
if [ "$action" == none ]; then
|
|
cd "$cwd"
|
|
return
|
|
fi
|
|
|
|
local build="${DEFAULTS[build_build]-1}"
|
|
local args
|
|
case "$PROFILE" in
|
|
prod|test) args="${DEFAULTS[composer_args]---no-dev -o}";;
|
|
*) args="${DEFAULTS[composer_args]}";;
|
|
esac
|
|
local php="${DEFAULTS[composer_php]}"
|
|
local php_max="${DEFAULTS[composer_php-max]}"
|
|
local image="${DEFAULTS[composer_image]}"
|
|
local machine="${DEFAULTS[composer_machine]}"
|
|
local host_mappings="${DEFAULTS[composer_host-mappings]-__UNDEFINED__}"
|
|
[ "$host_mappings" == __UNDEFINED__ ] && host_mappings="${DEFAULTS[docker_host-mappings]}"
|
|
local composer="${DEFAULTS[composer_composer]}"
|
|
local setup="${DEFAULTS[composer_setup]}"
|
|
local setup_image="${DEFAULTS[composer_setup-image]}"
|
|
local project_name="${DEFAULTS[composer_project-name]}"
|
|
if [ -f "$destdir/.composer.yaml" ]; then
|
|
eval "$(
|
|
COMPOSER_PHP=
|
|
COMPOSER_PHP_MAX=
|
|
COMPOSER_IMAGE="$COMPOSER_IMAGE"
|
|
COMPOSER_SETUP=
|
|
COMPOSER_SETUP_IMAGE=
|
|
eval "$(<"$destdir/.composer.yaml" grep ^composer_ |
|
|
sed 's/^composer_php_min: /COMPOSER_PHP=/
|
|
s/^composer_php_max: /COMPOSER_PHP_MAX=/
|
|
s/^composer_registry: /registry=/
|
|
s/^composer_image: \(.*\)/COMPOSER_IMAGE="${registry:-$REGISTRY}\/\1"/
|
|
s/^composer_setup: /COMPOSER_SETUP=/
|
|
s/^composer_setup_image: /COMPOSER_SETUP_IMAGE=/')"
|
|
[ -z "$php" ] && echo_setv php="$COMPOSER_PHP"
|
|
[ -z "$php_max" ] && echo_setv php_max="$COMPOSER_PHP_MAX"
|
|
[ -z "$image" ] && echo_setv image="$COMPOSER_IMAGE"
|
|
[ -z "$setup" ] && echo_setv setup="$COMPOSER_SETUP"
|
|
[ -z "$setup_image" ] && echo_setv setup_image="$COMPOSER_SETUP_IMAGE"
|
|
)"
|
|
elif [ -f "$destdir/.composer.conf" ]; then
|
|
eval "$(
|
|
COMPOSER_PHP=
|
|
COMPOSER_PHP_MAX=
|
|
COMPOSER_IMAGE="$COMPOSER_IMAGE"
|
|
COMPOSER_MACHINE=-u
|
|
COMPOSER_CMD=
|
|
COMPOSER_SETUP=
|
|
COMPOSER_SETUP_IMAGE=
|
|
source "$destdir/.composer.conf"
|
|
[ -z "$php" ] && echo_setv php="$COMPOSER_PHP"
|
|
[ -z "$php_max" ] && echo_setv php_max="$COMPOSER_PHP_MAX"
|
|
[ -z "$image" ] && echo_setv image="$COMPOSER_IMAGE"
|
|
[ -z "$machine" ] && echo_setv machine="$COMPOSER_MACHINE"
|
|
[ -z "$composer" ] && echo_setv composer="$COMPOSER_CMD"
|
|
[ -z "$setup" ] && echo_setv setup="$COMPOSER_SETUP"
|
|
[ -z "$setup_image" ] && echo_setv setup_image="$COMPOSER_SETUP_IMAGE"
|
|
)"
|
|
fi
|
|
|
|
while [ $# -gt 0 ]; do
|
|
case "$1" in
|
|
build) build=1;;
|
|
build=*) build="${1#build=}";;
|
|
args=*) args="${1#args=}";;
|
|
php=*) php="${1#php=}";;
|
|
php-max=*) php_max="${1#php-max=}";;
|
|
image=*) image="${1#image=}";;
|
|
machine=*) machine="${1#machine=}";;
|
|
host-mappings=*) host_mappings="${1#host-mappings=}";;
|
|
composer=*) composer="${1#composer=}";;
|
|
setup=*) setup="${1#setup=}";;
|
|
setup-image=*) setup_image="${1#setup-image=}";;
|
|
project-name=*) project_name="${1#project-name=}";;
|
|
*=*) ewarn "composer: $1: argument ignoré";;
|
|
*) break;;
|
|
esac
|
|
shift
|
|
done
|
|
|
|
if [ -z "$build" ]; then
|
|
cd "$cwd"
|
|
return
|
|
fi
|
|
|
|
if [ "$php" != force -a "$php" != any ]; then
|
|
# Si php n'est pas disponible dans le PATH, forcer l'utilisation de
|
|
# l'image
|
|
progexists php || php=force
|
|
fi
|
|
|
|
local use_image
|
|
if [ "$php" == force -o "$php" == any ]; then
|
|
use_image=1
|
|
elif [ "$php" == none -o "$php" == system ]; then
|
|
php=none
|
|
use_image=
|
|
elif [ -n "$php_max" -a "$php_max" != none ]; then
|
|
# Vérifier la version de PHP
|
|
php -r '
|
|
$version = $argv[1];
|
|
if (strpos($version, ".") !== false) {
|
|
$version = explode(".", $version);
|
|
$version = $version[0] * 10000 + $version[1] * 100 + (isset($version[2])? $version[2]: 0);
|
|
}
|
|
exit((PHP_VERSION_ID > $version)? 0: 1);
|
|
' -- "$php_max"
|
|
case $? in
|
|
0) use_image=1;;
|
|
1) use_image=;;
|
|
*) ewarn "Erreur lors du lancement de PHP: est-il installé? Sinon, utilisez php=any";;
|
|
esac
|
|
fi
|
|
if [ -n "$use_image" -o "$php" == none ]; then
|
|
: # ok, on a déjà décidé
|
|
elif [ -z "$php" ]; then
|
|
# pas de version minimum, tester simplement la valeur de image
|
|
[ "$image" != none ] && use_image=1
|
|
else
|
|
# Vérifier la version de PHP
|
|
php -r '
|
|
$version = $argv[1];
|
|
if (strpos($version, ".") !== false) {
|
|
$version = explode(".", $version);
|
|
$version = $version[0] * 10000 + $version[1] * 100 + (isset($version[2])? $version[2]: 0);
|
|
}
|
|
exit((PHP_VERSION_ID < $version)? 0: 1);
|
|
' -- "$php"
|
|
case $? in
|
|
0) use_image=1;;
|
|
1) use_image=;;
|
|
*) ewarn "Erreur lors du lancement de PHP: est-il installé? Sinon, utilisez php=any";;
|
|
esac
|
|
fi
|
|
|
|
if [ -n "$use_image" ]; then
|
|
if [ -z "$image" ]; then
|
|
# Si l'image n'est pas définie, calculer une valeur par défaut à
|
|
# partir REGISTRY et DIST
|
|
image="$(get_default_phpbuilder_image)"
|
|
fi
|
|
local orig_machine
|
|
[ "$image" != none ] || die "Vous devez spécifier l'image à utiliser pour composer"
|
|
if [ -n "$machine" -a "$machine" != current -a "$DOCKER_MACHINE_NAME" != "$machine" ]; then
|
|
orig_machine="$DOCKER_MACHINE_NAME"
|
|
set_machine "$machine"
|
|
fi
|
|
_docker_composer "$@"
|
|
if [ -n "$_orig_machine" ]; then
|
|
set_machine "$orig_machine"
|
|
fi
|
|
else
|
|
_local_composer "$@"
|
|
fi
|
|
|
|
# restaurer le répertoire courant
|
|
cd "$cwd"
|
|
}
|
|
function _local_mvn() {
|
|
if [ -n "$java" ]; then
|
|
urequire java
|
|
select_java_exact "$java" || die "mvn: Java $java introuvable"
|
|
export MVN_JAVA_VERSION="$java"
|
|
fi
|
|
|
|
case "$action" in
|
|
rootshell|rshell|rootbash|rbash)
|
|
shift
|
|
estep "Lancement d'un shell root"
|
|
sudo bash "$@"
|
|
return $?
|
|
;;
|
|
usershell|shell|userbash|bash)
|
|
shift
|
|
estep "Lancement d'un shell utilisateur"
|
|
bash "$@"
|
|
return $?
|
|
;;
|
|
java)
|
|
shift
|
|
estep "java"
|
|
java "$@"
|
|
;;
|
|
*)
|
|
estep "mvn $action"
|
|
|
|
[ -n "$mvn" ] || setx mvn=which mvn 2>/dev/null
|
|
[ -n "$mvn" ] || die "mvn: commande introuvable"
|
|
|
|
set -- "$action" $args "$@"
|
|
case "$1" in
|
|
install) set clean package install "${@:2}";;
|
|
package) set clean package "${@:2}";;
|
|
package_only) set package "${@:2}";;
|
|
esac
|
|
"$mvn" "$@"
|
|
esac
|
|
}
|
|
function _docker_mvn() {
|
|
local user group projdir actualcmd
|
|
setx user=id -un; setx user=getent passwd "$user"
|
|
setx group=id -gn; setx group=getent group "$group"
|
|
setx projdir=pwd
|
|
case "$action" in
|
|
rootshell|rshell|rootbash|rbash)
|
|
action=rshell
|
|
shift
|
|
actualcmd='eval "bash $args"'
|
|
;;
|
|
usershell|shell|userbash|bash)
|
|
action=shell
|
|
shift
|
|
actualcmd='eval "su-exec \"$user\" bash $args"'
|
|
;;
|
|
java)
|
|
shift
|
|
actualcmd='eval "su-exec \"$user\" java $args"'
|
|
;;
|
|
*)
|
|
actualcmd='eval "su-exec \"$user\" \"$mvn\" $args"'
|
|
|
|
set -- "$action" $args "$@"
|
|
case "$1" in
|
|
install) set clean package install "${@:2}";;
|
|
package) set clean package "${@:2}";;
|
|
package_only) set package "${@:2}";;
|
|
esac
|
|
args=
|
|
;;
|
|
esac
|
|
setx args=qvals $args "$@"
|
|
|
|
local -a basecmd setupscript runscript cmd
|
|
basecmd=(
|
|
-e user="$user"
|
|
-e group="$group"
|
|
-e projdir="$projdir"
|
|
-e setup="$setup"
|
|
-e setup_image="$setup_image"
|
|
-e mvn="$mvn"
|
|
-e args="$args"
|
|
${java:+-e JAVA="$java"}
|
|
)
|
|
eval "host_mappings=($host_mappings)"
|
|
for host_mapping in "${host_mappings[@]}"; do
|
|
basecmd+=(--add-host "$host_mapping")
|
|
done
|
|
basecmd+=(-v "$HOME:$HOME")
|
|
if [ "${projdir#$HOME/}" == "$projdir" ]; then
|
|
# si le répertoire de projet ne se trouve pas dans $HOME, le monter aussi
|
|
cmd+=(-v "$projdir:$projdir")
|
|
fi
|
|
setupscript='eval "$setup"'
|
|
runscript='
|
|
echo "$user" >>/etc/passwd; user="${user%%:*}"
|
|
echo "$group" >>/etc/group; group="${group%%:*}"
|
|
|
|
[ -n "$mvn" ] || mvn=mvn
|
|
|
|
cd "$projdir"
|
|
'"$actualcmd"
|
|
|
|
if [ -n "$setup" ]; then
|
|
local project_name container_name ctid
|
|
local setup_image="$setup_image"
|
|
|
|
# lancement dans un container docker à préparer
|
|
[ -n "$project_name" ] || setx project_name=get_project_name
|
|
setx container_name=get_container_name "$project_name"
|
|
[ -n "$setup_image" ] || setup_image="dkbuild_maven_${container_name}_image"
|
|
|
|
# vérifier l'existence de l'image
|
|
setx ctid=docker image ls --format '{{.ID}}' "$setup_image"
|
|
|
|
# créer le container le cas échéant
|
|
if [ -z "$ctid" ]; then
|
|
estep "Création de l'image $setup_image à partir de $image"
|
|
cmd=(
|
|
docker create -it --name "${setup_image}_tmpct"
|
|
"${basecmd[@]}"
|
|
"$image"
|
|
bash -c "$setupscript"
|
|
)
|
|
setx ctid="${cmd[@]}" &&
|
|
docker container start -ai "$ctid" &&
|
|
docker container commit "$ctid" "$setup_image" &&
|
|
docker container rm "$ctid" || die
|
|
fi
|
|
|
|
# prendre comme image le container créé
|
|
image="$setup_image"
|
|
fi
|
|
|
|
case "$action" in
|
|
rshell) estep "Lancement d'un shell root (avec l'image $image)";;
|
|
shell) estep "Lancement d'un shell utilisateur (avec l'image $image)";;
|
|
java) estep "java (avec l'image $image)";;
|
|
*) estep "mvn $action (avec l'image $image)";;
|
|
esac
|
|
cmd=(
|
|
docker run -it --rm
|
|
"${basecmd[@]}"
|
|
"$image"
|
|
bash -c "$runscript"
|
|
)
|
|
"${cmd[@]}"
|
|
}
|
|
function mvn() {
|
|
edebug "mvn $(qvals "$@")"
|
|
[ $# -eq 0 ] && return 0
|
|
|
|
local action destdir
|
|
[[ "$1" != *=* ]] && { destdir="$1"; shift; }
|
|
[[ "$1" != *=* ]] && { action="$1"; shift; }
|
|
|
|
[ -n "$destdir" ] || destdir=.
|
|
[ -d "$destdir" ] || die "mvn: $destdir: répertoire introuvable"
|
|
local cwd="$(pwd)"
|
|
cd "$destdir" || die
|
|
|
|
[ -n "$action" ] || action=package
|
|
if [ "$action" == none ]; then
|
|
cd "$cwd"
|
|
return
|
|
fi
|
|
|
|
local build="${DEFAULTS[build_build]-1}"
|
|
local args="${DEFAULTS[mvn_args]}"
|
|
local java="${DEFAULTS[mvn_java]}"
|
|
local image="${DEFAULTS[mvn_image]}"
|
|
local machine="${DEFAULTS[mvn_machine]}"
|
|
local host_mappings="${DEFAULTS[mvn_host-mappings]-__UNDEFINED__}"
|
|
[ "$host_mappings" == __UNDEFINED__ ] && host_mappings="${DEFAULTS[docker_host-mappings]}"
|
|
local mvn="${DEFAULTS[mvn_mvn]}"
|
|
local setup="${DEFAULTS[mvn_setup]}"
|
|
local setup_image="${DEFAULTS[mvn_setup-image]}"
|
|
local project_name="${DEFAULTS[mvn_project-name]}"
|
|
if [ -f "$destdir/.maven.conf" ]; then
|
|
eval "$(
|
|
MAVEN_JAVA=
|
|
MAVEN_IMAGE="$MAVEN_IMAGE"
|
|
MAVEN_MACHINE=-u
|
|
MAVEN_CMD=
|
|
MAVEN_SETUP=
|
|
MAVEN_SETUP_IMAGE=
|
|
source "$destdir/.maven.conf"
|
|
[ -z "$java" ] && echo_setv java="$MAVEN_JAVA"
|
|
[ -z "$image" ] && echo_setv image="$MAVEN_IMAGE"
|
|
[ -z "$machine" ] && echo_setv machine="$MAVEN_MACHINE"
|
|
[ -z "$mvn" ] && echo_setv mvn="$MAVEN_CMD"
|
|
[ -z "$setup" ] && echo_setv setup="$MAVEN_SETUP"
|
|
[ -z "$setup_image" ] && echo_setv setup_image="$MAVEN_SETUP_IMAGE"
|
|
)"
|
|
fi
|
|
|
|
while [ $# -gt 0 ]; do
|
|
case "$1" in
|
|
build) build=1;;
|
|
build=*) build="${1#build=}";;
|
|
args=*) args="${1#args=}";;
|
|
java=*) java="${1#java=}";;
|
|
image=*) image="${1#image=}";;
|
|
machine=*) machine="${1#machine=}";;
|
|
host-mappings=*) host_mappings="${1#host-mappings=}";;
|
|
mvn=*) mvn="${1#mvn=}";;
|
|
setup=*) setup="${1#setup=}";;
|
|
setup-image=*) setup_image="${1#setup-image=}";;
|
|
project-name=*) project_name="${1#project-name=}";;
|
|
*=*) ewarn "mvn: $1: argument ignoré";;
|
|
*) break;;
|
|
esac
|
|
shift
|
|
done
|
|
|
|
if [ -z "$build" ]; then
|
|
cd "$cwd"
|
|
return
|
|
fi
|
|
|
|
local version
|
|
case "$action" in
|
|
java*)
|
|
version="${action#java}"
|
|
[ -n "$version" ] && java="$version"
|
|
set java "${@:2}"
|
|
;;
|
|
esac
|
|
|
|
if [ "$java" != force -a "$java" != any ]; then
|
|
# Si Java et mvn ne sont pas disponibles dans le PATH, forcer
|
|
# l'utilisation de l'image
|
|
progexists java || java=force
|
|
progexists mvn || java=force
|
|
fi
|
|
|
|
local use_image
|
|
if [ "$java" == force -o "$java" == any ]; then
|
|
java=
|
|
use_image=1
|
|
elif [ "$java" == none -o "$java" == system ]; then
|
|
java=
|
|
use_image=
|
|
elif [ -n "$image" -a "$image" != none ]; then
|
|
use_image=1
|
|
fi
|
|
|
|
if [ -n "$use_image" ]; then
|
|
if [ -z "$image" ]; then
|
|
# Si l'image n'est pas définie, calculer une valeur par défaut à
|
|
# partir REGISTRY et DIST
|
|
image="$(get_default_javabuilder_image)"
|
|
fi
|
|
local orig_machine
|
|
[ "$image" != none ] || die "Vous devez spécifier l'image à utiliser pour mvn"
|
|
if [ -n "$machine" -a "$machine" != current -a "$DOCKER_MACHINE_NAME" != "$machine" ]; then
|
|
orig_machine="$DOCKER_MACHINE_NAME"
|
|
set_machine "$machine"
|
|
fi
|
|
_docker_mvn "$@"
|
|
if [ -n "$_orig_machine" ]; then
|
|
set_machine "$orig_machine"
|
|
fi
|
|
else
|
|
_local_mvn "$@"
|
|
fi
|
|
|
|
# restaurer le répertoire courant
|
|
cd "$cwd"
|
|
}
|
|
function run() {
|
|
edebug "run $(qvals "$@")"
|
|
[ $# -eq 0 ] && return 0
|
|
|
|
local cmd="$1"; shift
|
|
if [ "${cmd#/}" != "$cmd" ]; then :
|
|
elif [ "${cmd#./}" != "$cmd" ]; then :
|
|
elif [ "${cmd#../}" != "$cmd" ]; then :
|
|
else
|
|
local abscmd
|
|
setx abscmd=which "$cmd" 2>/dev/null
|
|
[ -n "$abscmd" ] || die "run: $cmd: commande introuvable"
|
|
edebug "'$cmd' resolved as '$abscmd'"
|
|
cmd="$abscmd"
|
|
fi
|
|
"$cmd" "$@" || die
|
|
}
|
|
function runb() {
|
|
local build="${DEFAULTS[build_build]-1}"
|
|
if [ -z "$build" ]; then
|
|
[ $# -eq 0 ] && return 1 || return 0
|
|
fi
|
|
run "$@"
|
|
}
|
|
function call() {
|
|
edebug "call $(qvals "$@")"
|
|
[ $# -eq 0 ] && return 0
|
|
|
|
"$@"
|
|
}
|
|
function callb() {
|
|
local build="${DEFAULTS[build_build]-1}"
|
|
if [ -z "$build" ]; then
|
|
[ $# -eq 0 ] && return 1 || return 0
|
|
fi
|
|
call "$@"
|
|
}
|
|
function dkbuild() {
|
|
edebug "dkbuild $(qvals "$@")"
|
|
|
|
"$SELF" "$@" || die
|
|
}
|
|
}
|
|
|
|
##~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
## init
|
|
|
|
function templates_action() {
|
|
declare -A TEMPLATES
|
|
[ -f "$TEMPLATEDIR/templates.conf" ] && source "$TEMPLATEDIR/templates.conf"
|
|
|
|
etitle "Templates valides"
|
|
local -a templates
|
|
setx -a templates=list_dirs "$TEMPLATEDIR"
|
|
for template in "${templates[@]}"; do
|
|
[ "$template" == default ] && continue
|
|
desc="${TEMPLATES[$template]}"
|
|
estep "$template${desc:+ - "$desc"}"
|
|
done
|
|
eend
|
|
}
|
|
|
|
##~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
## init
|
|
|
|
function init_action() {
|
|
eval "$SHARED_LOCALS1"
|
|
local template; local -a defaultvars addvars
|
|
local -a args; args=(
|
|
"${SHARED_ARGS1[@]}"
|
|
-t:,--template: template=
|
|
-v:,--var: '$addvars+=("$value_")'
|
|
-n:,--name: '$addvars+=(name="$value_")'
|
|
-g:,--group: '$addvars+=(group="$value_")'
|
|
)
|
|
parse_args "$@"; set -- "${args[@]}"
|
|
|
|
defaultvars=(name=name group=group)
|
|
[ $# -gt 0 ] && { [ -n "$1" ] && PROJDIR="$1"; shift; }
|
|
[ $# -gt 0 ] && { [ -n "$1" ] && addvars+=(name="$1"); shift; }
|
|
[ $# -gt 0 ] && { [ -n "$1" ] && addvars+=(group="$1"); shift; }
|
|
|
|
declare -A vars
|
|
local name value
|
|
for name in "${defaultvars[@]}" "${addvars[@]}"; do
|
|
if [[ "$name" == *=* ]]; then
|
|
value="${name#*=}"
|
|
name="${name%%=*}"
|
|
else
|
|
value=
|
|
fi
|
|
name="${name^^}"
|
|
vars[$name]="$value"
|
|
done
|
|
|
|
[ -n "$template" ] || template=default
|
|
[ -d "$TEMPLATEDIR/$template" ] || die "$template: template introuvable"
|
|
|
|
[ -n "$PROJDIR" ] || PROJDIR=.
|
|
setx PROJDIR=abspath "$PROJDIR"
|
|
if [ ! -d "$PROJDIR" ]; then
|
|
ask_yesno "Voulez-vous créer le nouveau projet $(ppath "$PROJDIR")?" O || die
|
|
fi
|
|
mkdir -p "$PROJDIR"
|
|
|
|
local sedscript
|
|
for name in "${!vars[@]}"; do
|
|
value="${vars[$name]}"
|
|
[ -n "$sedscript" ] && sedscript="$sedscript; "
|
|
sedscript="${sedscript}s/${name//\//\\\/}/${value//\//\\\/}/g"
|
|
done
|
|
|
|
local src mode dest link
|
|
template="$TEMPLATEDIR/$template"
|
|
enote "Initialisation de $(ppath "$PROJDIR")"
|
|
find "$template/" -type f -o -type l | while read src; do
|
|
dest="$PROJDIR/${src#$template/}"
|
|
if [ -L "$src" ]; then
|
|
setx link=readlink "$src"
|
|
if [ -L "$dest" ]; then
|
|
if [ "$(readlink "$dest")" != "$link" ]; then
|
|
estep "${src#$template/} [link, updated]"
|
|
ln -sf "$link" "$dest"
|
|
else
|
|
edebug "${src#$template/} [exists, ignored]"
|
|
fi
|
|
elif [ -e "$dest" ]; then
|
|
estepe "${src#$template/} [destination is not a link]"
|
|
else
|
|
estep "${src#$template/} [link]"
|
|
ln -s "$link" "$dest"
|
|
fi
|
|
elif [ -f "$dest" ]; then
|
|
edebug "${src#$template/} [exists, ignored]"
|
|
else
|
|
estep "${src#$template/}"
|
|
mkdirof "$dest"
|
|
sed <"$src" >"$dest" "$sedscript"
|
|
setx mode=stat -c %a "$src"
|
|
chmod "$mode" "$dest"
|
|
fi
|
|
done
|
|
}
|
|
|
|
##~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
## build
|
|
|
|
function build_action() {
|
|
eval "$SHARED_LOCALS1; $SHARED_LOCALS2"
|
|
local action=build
|
|
local machine
|
|
local clean_update clean_opt=-X
|
|
local clone_src_only update_src_only update_src sync_src
|
|
local build no_cache progress pull_image
|
|
local push_image
|
|
local -a args; args=(
|
|
"${SHARED_ARGS1[@]}" "${SHARED_ARGS2[@]}"
|
|
-m:,--machine: machine=
|
|
-u,--clean-update clean_update=1
|
|
-X,--clean-ignored clean_opt=-X
|
|
-x,--clean-untracked clean_opt=-x
|
|
--clone-src-only clone_src_only=1
|
|
--update-src-only update_src_only=1
|
|
--update-src update_src=1
|
|
--no-update-src update_src=no
|
|
-w,--update-devel-src update_src=devel
|
|
-s,--sync-src sync_src=1
|
|
--no-sync-src sync_src=no
|
|
-b,--build build=1
|
|
--no-cache no_cache=1
|
|
--plain-output progress=plain
|
|
-U,--pull-image pull_image=1
|
|
-p,--push-image push_image=1
|
|
)
|
|
parse_args "$@"; set -- "${args[@]}"
|
|
|
|
if [ -n "$clone_src_only" ]; then
|
|
action=clone_src
|
|
elif [ -n "$update_src_only" ]; then
|
|
action=update_src
|
|
else
|
|
action=build
|
|
if [ -z "$clean_update" -a -z "$sync_src" -a -z "$build" -a -z "$push_image" ]; then
|
|
sync_src=1
|
|
build=1
|
|
fi
|
|
if [ -n "$build" ]; then
|
|
[ -n "$update_src" ] || update_src=1
|
|
[ "$update_src" == no ] && update_src=
|
|
else
|
|
update_src=
|
|
fi
|
|
[ "$sync_src" == no ] && sync_src=
|
|
fi
|
|
|
|
edebug "build_action"
|
|
set_machine "$machine"
|
|
|
|
ensure_projdir
|
|
resolve_dists_profiles
|
|
setenv "${TMPENVIRON[@]}"
|
|
setarg "${TMPARGS[@]}"
|
|
setarg "$@"
|
|
|
|
if [ -n "$clean_update" ]; then
|
|
edebug "clean"
|
|
_clean_git_clean -f || die
|
|
|
|
edebug "update"
|
|
git pull || die
|
|
|
|
edebug "sync"
|
|
[ -n "$build" ] && sync_src=1
|
|
fi
|
|
|
|
case "$action" in
|
|
clone_src)
|
|
die "Pas encore implémenté" #XXX
|
|
;;
|
|
update_src)
|
|
die "Pas encore implémenté" #XXX
|
|
;;
|
|
build)
|
|
default checkout checkout="$update_src"
|
|
default copy copy="$sync_src"
|
|
default build build="$build" ${no_cache:+no-cache} ${pull_image:+pull} ${push_image:+push}
|
|
[ $# -gt 0 ] && default build "$@"
|
|
define_functions_cmd
|
|
|
|
foreach_dists_profiles _build_each _build_before _build_after
|
|
;;
|
|
esac
|
|
}
|
|
|
|
function _build_before() {
|
|
PREV_DIST=
|
|
PREV_PROFILE=
|
|
}
|
|
function _build_each() {
|
|
if [ -n "$DIST" -a "$DIST-$DVERSION" != "$PREV_DIST" ]; then
|
|
[ -n "$PREV_PROFILE" ] && eend
|
|
PREV_PROFILE=
|
|
|
|
[ -n "$PREV_DIST" ] && eend
|
|
PREV_DIST="$DIST-$DVERSION"
|
|
etitle "Distribution ${DVERSION:+$DVERSION-}$DIST"
|
|
fi
|
|
if [ -n "$PROFILE" -a "$PROFILE-$PVERSION" != "$PREV_PROFILE" ]; then
|
|
PREV_PROFILE="$PROFILE-$PVERSION"
|
|
etitle "Profil ${PVERSION:+$PVERSION-}$PROFILE"
|
|
fi
|
|
|
|
load_dkbuild
|
|
if [ -n "$AUTOBUILD" ]; then
|
|
if [ -f docker-compose.yml ]; then
|
|
cbuild
|
|
else
|
|
build
|
|
fi
|
|
fi
|
|
}
|
|
function _build_after() {
|
|
if [ -n "$PREV_PROFILE" ]; then eend; fi
|
|
if [ -n "$PREV_DIST" ]; then eend; fi
|
|
}
|
|
|
|
##~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
## clean
|
|
|
|
function _clean_git_clean() {
|
|
LANG=C git clean -d $clean_opt "$@" |
|
|
grep -vE '^(Would skip|Skipping) ' |
|
|
sed -r 's/^Would remove //'
|
|
}
|
|
function _clean_git_status() {
|
|
git status --porcelain --ignored |
|
|
grep '^!! ' |
|
|
sed 's/^...//'
|
|
}
|
|
|
|
function clean_action() {
|
|
eval "$SHARED_LOCALS1"
|
|
local clean_opt=-X all=
|
|
local -a args; args=(
|
|
"${SHARED_ARGS1[@]}"
|
|
-X,--ignored clean_opt=-X
|
|
-x,--untracked clean_opt=-x
|
|
-a,--all all=1
|
|
)
|
|
parse_args "$@"; set -- "${args[@]}"
|
|
|
|
[ -n "$all" ] && clean_opt=-x
|
|
|
|
edebug "clean_action"
|
|
ensure_projdir
|
|
|
|
local cleans
|
|
setx cleans=_clean_git_clean -n "$@"
|
|
if [ -n "$cleans" ]; then
|
|
if check_interaction -c; then
|
|
einfo "via git clean"
|
|
eecho "$cleans"
|
|
ask_yesno "Voulez-vous supprimer ces fichiers?" O || die
|
|
fi
|
|
|
|
_clean_git_clean -f "$@" || die
|
|
fi
|
|
|
|
if [ -n "$all" ]; then
|
|
setx cleans=_clean_git_status
|
|
if [ -n "$cleans" ]; then
|
|
if check_interaction -c; then
|
|
einfo "via git status"
|
|
eecho "$cleans"
|
|
ask_yesno "Voulez-vous supprimer ces fichiers supplémentaires?" O || die
|
|
fi
|
|
|
|
sed 's/^/Removing /' <<<"$cleans"
|
|
eval "cleans=($cleans);"' rm -rf "${cleans[@]}"' || die
|
|
fi
|
|
fi
|
|
}
|
|
|
|
##~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
## composer
|
|
|
|
function composer_action() {
|
|
local -a args; args=(
|
|
)
|
|
parse_args "$@"; set -- "${args[@]}"
|
|
|
|
[ $# -gt 0 ] || set .
|
|
|
|
edebug "composer_action"
|
|
|
|
define_functions_cmd
|
|
composer "$@"
|
|
}
|
|
|
|
##~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
## mvn
|
|
|
|
function mvn_action() {
|
|
local -a args; args=(
|
|
)
|
|
parse_args "$@"; set -- "${args[@]}"
|
|
|
|
[ $# -gt 0 ] || set .
|
|
|
|
edebug "mvn_action"
|
|
|
|
define_functions_cmd
|
|
mvn "$@"
|
|
}
|
|
|
|
##~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
## dump
|
|
|
|
function dump_action() {
|
|
eval "$SHARED_LOCALS1; $SHARED_LOCALS2"
|
|
local machine
|
|
local -a args; args=(
|
|
"${SHARED_ARGS1[@]}" "${SHARED_ARGS2[@]}"
|
|
-m:,--machine: machine=
|
|
)
|
|
parse_args "$@"; set -- "${args[@]}"
|
|
|
|
edebug "dump_action"
|
|
set_machine "$machine"
|
|
|
|
ensure_projdir
|
|
resolve_dists_profiles
|
|
setenv "${TMPENVIRON[@]}"
|
|
setarg "${TMPARGS[@]}"
|
|
setarg "$@"
|
|
|
|
foreach_dists_profiles _dump_each _dump_before _dump_after
|
|
}
|
|
|
|
function _dump_before() {
|
|
PREV_DIST=
|
|
PREV_PROFILE=
|
|
}
|
|
function _dump_each() {
|
|
if [ -n "$DIST" -a "$DIST-$DVERSION" != "$PREV_DIST" ]; then
|
|
[ -n "$PREV_PROFILE" ] && eend
|
|
PREV_PROFILE=
|
|
|
|
[ -n "$PREV_DIST" ] && eend
|
|
PREV_DIST="$DIST-$DVERSION"
|
|
etitle "Distribution ${DVERSION:+$DVERSION-}$DIST"
|
|
fi
|
|
if [ -n "$PROFILE" -a "$PROFILE-$PVERSION" != "$PREV_PROFILE" ]; then
|
|
PREV_PROFILE="$PROFILE-$PVERSION"
|
|
etitle "Profil ${PVERSION:+$PVERSION-}$PROFILE"
|
|
fi
|
|
|
|
load_dkbuild
|
|
|
|
etitle "Variables d'environnement"
|
|
for name in "${!ENVIRON[@]}"; do
|
|
estep "$name=${ENVIRON[$name]}"
|
|
done
|
|
eend
|
|
|
|
etitle "Variables de build"
|
|
for name in "${!ARGS[@]}"; do
|
|
estep "$name=${ARGS[$name]}"
|
|
done
|
|
eend
|
|
|
|
etitle "Valeurs par défaut"
|
|
for name in "${!DEFAULTS[@]}"; do
|
|
estep "$name=${DEFAULTS[$name]}"
|
|
done
|
|
eend
|
|
}
|
|
function _dump_after() {
|
|
if [ -n "$PREV_PROFILE" ]; then eend; fi
|
|
if [ -n "$PREV_DIST" ]; then eend; fi
|
|
}
|
|
|
|
##~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
##
|
|
|
|
# faire une copie de l'environnement original
|
|
load_environ
|
|
|
|
# si aucune action n'est spécifiée, il faut inférer build pour que ses options
|
|
# soient reconnues
|
|
args=()
|
|
while [ $# -gt 0 ]; do
|
|
case "$1" in
|
|
--help) args+=("$1"); shift; continue;;
|
|
--hdk|--help-dkbuild) args+=("$1"); shift; continue;;
|
|
--href|--help-reference) args+=("$1"); shift; continue;;
|
|
--compose-v1) args+=("$1"); shift; continue;;
|
|
-*|*=*) # option quelconque: inférer build
|
|
args+=(build)
|
|
break
|
|
;;
|
|
*) # argument quelconque: on s'arrête ici
|
|
break
|
|
;;
|
|
esac
|
|
done
|
|
set -- "${args[@]}" "$@"
|
|
|
|
args=(+
|
|
--help '$exit_with display_help'
|
|
--hdk,--help-dkbuild '$exit_with display_help_dkbuild'
|
|
--href,--help-reference '$exit_with display_help_reference'
|
|
--compose-v1 '$DOCKER_COMPOSE=(docker-compose)'
|
|
)
|
|
parse_args "$@"; set -- "${args[@]}"
|
|
|
|
# aliases
|
|
case "$1" in
|
|
ci) set composer "$2" install "${@:3}";;
|
|
cu) set composer "$2" update "${@:3}";;
|
|
cr) set composer "$2" rshell "${@:3}";;
|
|
cs) set composer "$2" shell "${@:3}";;
|
|
mvr) set mvn "$2" rshell "${@:3}";;
|
|
mvs) set mvn "$2" shell "${@:3}";;
|
|
java) set mvn "$2" java "${@:3}";;
|
|
esac
|
|
|
|
# actions
|
|
action="${1:-build}"; shift
|
|
case "$action" in
|
|
templates|t) templates_action "$@";;
|
|
init|i|0) init_action "$@";;
|
|
build|b) build_action "$@";;
|
|
clean|k) clean_action "$@";;
|
|
composer|c) composer_action "$@";;
|
|
maven|mvn|m) mvn_action "$@";;
|
|
dump|d) dump_action "$@";;
|
|
*) die "$action: action invalide";;
|
|
esac
|