Contenu | Rechercher | Menus

Annonce

Ubuntu 16.04 LTS
Commandez vos DVD et clés USB Ubuntu-fr !

Pour en savoir un peu plus sur l'équipe du forum.

Si vous avez des soucis pour rester connecté, déconnectez-vous puis reconnectez-vous depuis ce lien en cochant la case
Me connecter automatiquement lors de mes prochaines visites.

#1 Le 12/09/2016, à 16:20

kholo

[tuto bash]script lanceur de script et post install 16.04

bonjour,
pour apprendre rien de tel qu'un projet...

Prélude
Je fais des tutos et donne des infos qui sont souvent regroupable en suites qui peuvent donner des scripts...
Souvent je sais qu'une fonction existe mais la syntaxe et les options ne me rentrent pas dans la tête...
L'idée de se script est de réunir les principaux besoins en terme de log (écriture), fichier conf (lecture et écriture), quelques parseurs pour faire tout ça, l'utilisation simple de fonctions, les variables, zenity...
le but ici sera d'installer ou plutôt recréer un ensemble de scripts et sous scripts et de créer le "programme ultime" de post installation de ubuntu (et même pour d'autres distributions).
Pour l'instant, le lanceur principal.
1473763308.png
Le projet :
Pour automatiser et simplifier le lancement de ces scripts, j'ai pensé à un lanceur de script.
Pour comprendre, j'ai fais un hello world et un ensemble pour la post install de ubuntu 16.04+ on le verra dans le prochain post
Chaque script peut être lancé sans le lanceur qui ne sert qu'à regrouper et donner une interface graphique.
Dans les scripts le mot de passe root peut être demandé. Il le sera à chaque premier sudo de chaque script et éventuellement d'autre fois si le script s'éternise.
Dans cette première partie je vais donner les instructions qui permettent de créer le système de lanceur en ligne de commande pour n'avoir à faire que du copier coller.
PS : pas de sudo, on joue à domicile !

On y va !
Ouvrez un terminal et passez le au premier plan (clic droit dans la barre du haut puis "mettre au premier plan"),
réduisez sa taille pour pouvoir lire et copier les lignes de code qui vont suivre :
au cas où il n'existerait pas encore, on crée un dossier bin dans le dossier personnel
qui servira à regrouper tous les script.
NB : quand ce dossier est présent, Ubuntu l'ajoute automatiquement au PATH
(sans doute après avoir relancer la session)

mkdir $HOME/bin

tous les scripts personnels de chaque utilisateur doivent (selon la norme...) être ici.
NB : $HOME : voir les variables d'environnement -> $HOME :  /home/nom_de_l_utilisateur

On crée un dossier pour tester

mkdir $HOME/bin/lanceur

on ajoute le programme à proprement parlé en l'éditant avec gedit

gedit $HOME/bin/lanceur/installer.sh

copier / coller le code suivant

#!/bin/bash

# nomlogiciel="$(basename "$0")"
nomlogiciel="${0##*/}"
# FONCTION=""
VERSION="alpha"
# NOTES DE VERSIONS

# function _initialisation {
echo "*******************initialisation*******************" ;

# SCRIPT_PATH="$(pwd)/${0%/*}/" ;
SCRIPT_PATH="$(pwd)" ;
INSTALL_PATH="${SCRIPT_PATH}/bin/" ;
TWEAKLIST_FILE="${SCRIPT_PATH}/tweaklist" ;
FICHIER_LOG="installer.log" ;
FICHIER_INI="installer.ini" ;

function _journal {
	FICHIER_LOG="$nomLogiciel.log" ;

	if [ ! -f "$FICHIER_LOG" ]; then
		echo "CreateLogfile : $FICHIER_LOG" ;
		touch "$FICHIER_LOG";
	fi
}

function journal {
	echo "$@"|tee -a "$FICHIER_LOG" ;
}
echo "ouverture du journal" ;
_journal

# charger Initialisation
function _ini_File {
	if [ -f "$FICHIER_INI" ];
	then
		chargerIni ;
	else
		touch "$FICHIER_INI" ;
		sauverIni ;
	fi 
}

function chargerIni {
	while read line ;
	do
		parserLigneIni "$line" ;
		
	done < "$FICHIER_INI" ;
}

function sauverIni {
	# cd "$SCRIPT_PATH"

printf '%s' "SCRIPT_PATH=$SCRIPT_PATH
INSTALL_PATH=$INSTALL_PATH
TWEAKLIST_FILE=$TWEAKLIST_FILE
" > "$SCRIPT_PATH/$FICHIER_INI" ;
}

# # journal "Chargement..." "parserLigneIni"
function parserLigneIni {
	i=$@ ;
	case $i in
		# xxxxx=*)					xxxxxx="${i#*=}" ;;
		SCRIPT_PATH=*)					SCRIPT_PATH="${i#*=}" ;;
		INSTALL_PATH=*)					INSTALL_PATH="${i#*=}" ;;
		TWEAKLIST_FILE=*)				TWEAKLIST_FILE="${i#*=}" ;;
	esac
}
_ini_File ;


function _quitter {
	# mettre ici tout ce qui sera nescessaire à la bonne fermeture
	sauverIni ;
	exit 0
}
# ---------------------------------------------------

# Choisir le dossier des modules
INSTALL_PATH=$(zenity --file-selection \
--filename="${INSTALL_PATH}" \
--title="Veuillez selectionner un dossier" \
--text="Choissisez un dossier quelconque
Annulez pour conserver 
${INSTALL_PATH}
" \
--directory);
if [ $? = 0 ]
then
	echo "Le dossier est : "
	echo ${INSTALL_PATH} ;
	echo "***************************** "
else
	_quitter
fi

# création de la liste de tweaks
TWEAKLIST_FILE="${SCRIPT_PATH}/tweaklist"
ls "${INSTALL_PATH}/" > "$TWEAKLIST_FILE"

title="Choisissez des options"
my_text="Sélectionnez les modules à installer"
nbreArg=0
ARG=""

# Changement du caractère de séparation de zenity
OLDIFS="$IFS"
IFS='|'
while read line
do
	# journal "${line}" ;
	if [ "$(ls "${INSTALL_PATH}/$line/" | grep "install.sh" ;)"="install.sh" ] ; then
		nbreArg="$(expr $nbreArg + 1)"
		# ARG=$(echo "${ARG}"TRUE"|${line}|")
		# ou ARG=$(echo "${ARG}"FALSE"|${line}|")
		ARG=$(printf '%s' "${ARG}FALSE|${line}|")
	fi
done < "${TWEAKLIST_FILE}" ;

mesSelections="$(zenity --list --separator="$IFS" \
--width=500 --height=650 \
--title="$title" \
--text "$my_text" --checklist \
--column "choix" --column "Valeur" \
${ARG};)";
if [ $? = 0 ]
then
	echo "Continuer "
	echo "***************************** "
else
	_quitter
fi

echo -n > "${TWEAKLIST_FILE}"

for uneSelection in ${mesSelections} ; do
	echo $uneSelection >> "${TWEAKLIST_FILE}"
done

# Rétablissement du caractère de séparation dans Zenity
IFS="$OLDIFS"

# "Installer Packs"
cd "${INSTALL_PATH}/"
#récupère le nom des tweaks (uniquement) du fichier tweaklist par ligne
while read line  
do
	if [ "$(ls "${INSTALL_PATH}/$line/" | grep "install.sh" ;)"="install.sh" ] ;then
		cd "$line/"
		xterm -e "./install.sh"
		cd ..
	fi
done < "${TWEAKLIST_FILE}" ;
cd "$SCRIPT_PATH"

_quitter ;
exit 0

Enregistrez et fermer gedit (ctrl + s puis ctrl + q)
on rend le fichier exécutable

chmod +x $HOME/bin/lanceur/installer.sh

et on continue les créations...
ici un dossier qui servira de dossier par défaut et pour faire des tests

mkdir $HOME/bin/lanceur/bin

maintenant on crée le premier module
pour mettre plusieurs modules dans un ordre déterminé, il suffit de faire commencer le nom par un nombre
on verra ça dans le module exemple de "post install"

mkdir "$HOME/bin/lanceur/bin/hello word"
gedit "$HOME/bin/lanceur/bin/hello word/install.sh"

copier / coller le code suivant

#!/bin/bash
# ----------------------------------------------
FONCTION="Hello World" ;
VERSION="alpha" ;
# NOTES DE VERSIONS

echo "lancement 
$FONCTION..." ;

zenity --info --text="$FONCTION" ;

exit 0

on le rend exécutable

chmod +x "$HOME/bin/lanceur/bin/hello word/install.sh"

plus qu'à lancer le programme de base pour voir si cela marche
./bin/lanceur/installer.sh

cd ~/bin/lanceur/
./installer.sh

au premier lancement, le script vous demande de choisir un dossier en partant de votre dossier personnel ~/bin
entrez dedans puis entrez dans le dossier lanceur que vous avez créé puis dans le dossier bin
(les prochaines fois, le programme partira directement du dossier bin du programme)
choisissez bin mais n'entrez pas dans "hello world"... validez
cochez hello word puis lancez le script par l'interface de zenity
... ça va afficher la fenêtre Zenity avec "Hello World"

j'ajouterai par la suite la création d'un lien entre le script et le dossier bin personnel

-----------------------------------------------------------------------------
edit du 29/05//2017 :
Pour info je met mon script en état d'avancement v.0.39 :

#!/bin/bash
# Pour éviter d'accéder en lecture à une variable n'ayant pas d'existence, 
# on peut inscrire la commande set -u en début de script.
set -u

NOM_DU_LOGICIEL="${0##*/}"
FONCTION="lanceur de scripts ; installeurs, patchs, ppa,..."
VERSION="0.39"

#~**************************************************************
#~l'utilisateur est il sudoer ?
#~**************************************************************
#~echo "l'utilisateur est il sudoer ?"
#~[ -n "$( groups $USER | grep sudo )" ] && echo oui || echo non
[ -n "$( groups $USER | grep sudo )" ] || {
msgbox "ATTENTION - $USER n'est pas sudoer et ne pourra pas exécuter certaines fonctions"
# exit 1
}
#~**************************************************************
# 

CHEMIN_DU_PGM="${PWD}" ;
CHEMIN_DE_DATA="${CHEMIN_DU_PGM}/data" ;
CHEMIN_DES_IMAGES="${CHEMIN_DU_PGM}/images" ;
CHEMIN_DES_MODULES="${CHEMIN_DU_PGM}/data" ;
FICHIER_TWEAKLIST="${CHEMIN_DU_PGM}/tweaklist" ;
FICHIER_LOG="${CHEMIN_DU_PGM}/${NOM_DU_LOGICIEL}.log" ;
FICHIER_INI="${CHEMIN_DU_PGM}/${NOM_DU_LOGICIEL}.ini" ;
FICHIER_AIDE="${CHEMIN_DU_PGM}/LisezMoi.txt" ;
SITE_DOWNLOAD="http://www.kholo-informatique.fr/download"
IMG_SPLASH="PIL2017-logo.png"

#~**************************************************************
function localisation () {
echo "
appel de : localisation
	argument : ${@}"

VA="Créer un choix de liste"
VB="Voir le choix de liste en cours"
VC="Lancer le choix de liste"

VH="Téléchargement"
VI="voir l'aide"
VZ="Quitter"
txt_LAQUESTION="
----------------------
Ce module est le lanceur des ensembles d'installateurs
Vous allez pouvoir choisir un dossier dans lequel se trouvent les dossiers des installeurs

Une fois lancé, vous aurez des cases à cocher pour sélectionner des actions à réaliser
Pour chaque action, vous aurez une explication et la possibilité d'annuler le lancement
----------------------
double cliquez sur une ligne pour la lancer ou clic simple puis lancer avec le bouton valider
"
txt_ok_label="Appliquer"
# txt_cancel_label="Quitter"
txt_cancel_label="Sélectionnez puis --->"
txt_choice="choix"
txt_value="Valeur"
txt_Dossier_install="Dossier d'installation"
txt_Choisissez_Options="Choisissez des options"
txt_Select_Modules="Sélectionnez les modules à installer"
txt_Select_Dossier="Veuillez selectionner un dossier"
txt_Select_DossierInfos="Choissisez un dossier quelconque
Annulez pour conserver "
txt_FICHIER_AIDE="POST INSTALLATION UBUNTU 16.04 - Le PC à Kiki

Suite à ce tuto initialement posté sur le forum de Ubuntu fr
https://forum.ubuntu-fr.org/viewtopic.php?id=1993089

transcription en script bash.

Principe :
Le script principal n'est qu'un luncheur qui recense les dossiers 
contenu dans un dossier à choisir 
ET qui contiennent des dossiers avec un fichier install.sh 
puis écrit les informations dans un fichier texte (tweaklist)
pour le reprendre ensuite et installer chaque ligne comme un nom de dossier 
dans lequel se trouve le fichier install.sh

Chaque install.sh peut être lancé indépendement sans dépendance.
Il sont tous commencés par une fenetre en zenity pour expliquer le script 
et pouvoir éventuellement sortir.

tout est lancé dans un sous terminal qui permet de lire les retours éventuels.

Utilisation :
lancer $0 (pas de droits élevés)
$0
choisir un dossier dans data/
cocher les actions à accomplir
lancer et donner le mot de passe root pour chaque nouvelle action
si celui ci est demandé.



TODO installation des dépendances :
la totalité des pgms utilisés doivent faire parti du système ou de bash :
cd, zenity, sed, echo, function,..."
	}
localisation ;

#~**************************************************************
if [ ! -d "${CHEMIN_DE_DATA}" ] ; then 
	journal "Erreur de chemin - création dossier data" ;
	mkdir "${CHEMIN_DE_DATA}" ;
fi
if [ ! -d "${CHEMIN_DES_IMAGES}" ] ; then 
	journal "Erreur de chemin - création dossier images" ;
	mkdir "${CHEMIN_DES_IMAGES}" ;
	# TODO téléchagements de compléments
	wget "${SITE_DOWNLOAD}/images/${IMG_SPLASH}" -O "${CHEMIN_DES_IMAGES}/${IMG_SPLASH}"
fi

#~**************************************************************
function splashScreen () {
(echo "<h1>PIL v$VERSION</h1><img src=\"data:"
 mimetype -b "$1"
 echo -n ";base64,"
 base64 "$1"
 echo "\">" ;) | zenity --text-info --width=400 --height=500 --ok-label="Go" --cancel-label="" --html --filename=/dev/stdin
}
splashScreen "${CHEMIN_DES_IMAGES}/${IMG_SPLASH}" >/dev/null ;

#~**************************************************************
echo "ouverture du journal" ;
function _journal () {
	# FICHIER_LOG="$NOM_DU_LOGICIEL.log" ;
	[ -f "${FICHIER_LOG}" ] || { touch "${FICHIER_LOG}" ;
		echo "Création du fichier de log : ${FICHIER_LOG##*/}" ;
	}
	}
function journal () { echo "[$(date +%H:%M:%S)] ${@}" | tee -a "${FICHIER_LOG}" >/dev/null ; }

_journal ;
echo -n | tee "${FICHIER_LOG}" >/dev/null ;
journal "$(date)
lancement principal
argument : ${@}"
#~**************************************************************
function _iniFile () {
	journal "appel de : ${FUNCNAME}
	argument : ${@}"
	if [ -f "${FICHIER_INI}" ]; then
		chargerIni ;
	else
		journal "création fichier ini"
		touch "${FICHIER_INI}" ;
		sauverIni ;
	fi 
	journal "sortie ${FUNCNAME} : $?"
	}
function chargerIni () {
	journal "appel de : ${FUNCNAME}
	argument : ${@}"
	while read line ;
	do
		parserLigneIni "$line" ;
	done < "${FICHIER_INI}" ;

	if [ ! -d "$CHEMIN_DU_PGM" ] ; 
	then 
		localisation ;
		journal "Erreur de chemin - fichier ini ré-initialisé" ;
		sauverIni ;
	fi
	journal "sortie ${FUNCNAME} : $?"
	}
function sauverIni () {
journal "appel de : ${FUNCNAME}
	argument : ${@}"
echo "CHEMIN_DU_PGM=${CHEMIN_DU_PGM}
FICHIER_TWEAKLIST=${FICHIER_TWEAKLIST}
FICHIER_LOG=${FICHIER_LOG}
FICHIER_INI=${FICHIER_INI}
FICHIER_AIDE=${FICHIER_AIDE}
CHEMIN_DE_DATA=${CHEMIN_DE_DATA}
CHEMIN_DES_IMAGES==${CHEMIN_DES_IMAGES=}
CHEMIN_DES_MODULES=${CHEMIN_DES_MODULES}
" | tee "${FICHIER_INI}" >/dev/null ;
	journal "sortie ${FUNCNAME} : $?"
	}
function parserLigneIni () {
	journal "appel de : ${FUNCNAME}
	argument : ${@}"
	i=${@} ;
	case $i in
		#~xxxxx=*)				xxxxxx="${i#*=}" ;;
		CHEMIN_DU_PGM=*)		CHEMIN_DU_PGM="${i#*=}" ;;
		FICHIER_TWEAKLIST=*)	FICHIER_TWEAKLIST="${i#*=}" ;;
		FICHIER_LOG=*)			FICHIER_LOG="${i#*=}" ;;
		FICHIER_INI=*)			FICHIER_INI="${i#*=}" ;;
		FICHIER_AIDE=*)			FICHIER_AIDE="${i#*=}" ;;
		CHEMIN_DE_DATA=*)		CHEMIN_DE_DATA="${i#*=}" ;;
		CHEMIN_DES_IMAGES==*)	CHEMIN_DES_IMAGES=="${i#*=}" ;;
		CHEMIN_DES_MODULES=*)	CHEMIN_DES_MODULES="${i#*=}" ;;
	esac
	}

_iniFile ;

#~**************************************************************
function msgbox () {
	zenity --info --text="${@}" --no-wrap ;
	}
function _quitter () {
journal "appel de : ${FUNCNAME}
	argument : ${@}"
	#~mettre ici tout ce qui sera nescessaire à la bonne fermeture
	sauverIni 
	exit 0
	}
function FRM_PRINCIPALE () {
zenity --list --width=600 --height=480 --text="${txt_LAQUESTION}" \
	--ok-label="${txt_ok_label}" \
	--cancel-label="${txt_cancel_label}" \
	--column "${txt_choice}" --column "${txt_value}" \
	1 "$VA" 2 "$VB" 3 "$VC" 0 "" 7 "$VH - désactivé" 8 "$VI" 9 "$VZ" ;
	journal "sortie ${FUNCNAME} : $?"
	}
function AfficherTweaklist () {
	journal "appel de : ${FUNCNAME}
	argument : ${@}"
	local retours
	local retours2
	local retoursX

	retours=${CHEMIN_DES_MODULES}
	retours2=${retours%'/'*}
	let "LG = ${#retours} - ${#retours2}"
	retoursX=${retours:${#retours2}:$LG} 
	msgbox "$txt_Dossier_install :\n$retoursX\n---------------------\n$(cat "${FICHIER_TWEAKLIST}")"
	journal "sortie ${FUNCNAME} : $?"

	}
function afficher_aide () { 
	msgbox "$(echo "$txt_FICHIER_AIDE")" 
	}
function MaJDesData (){
	journal "appel de : ${FUNCNAME}
	argument : ${@}"
	local CHEMIN_COURANT="${PWD}"

	cd "${CHEMIN_DE_DATA}"
	# VERSIONs de kiPIL
	# leFICHIER="$(curl ${SITE_DOWNLOAD}/version.txt)"  >/dev/null ;
	# msgbox "Votre version : $VERSION\nversion web ${leFICHIER}"

	local lesData="$(curl ${SITE_DOWNLOAD}/data.txt)"  >/dev/null ;
	IFS=$'\n' lesData=( $lesData )
	for undata in ${lesData[@]} ; do
		journal "------ Téléchargement de $undata ------"
		# msgbox "------ Téléchargement de $undata ------"
		wget "${SITE_DOWNLOAD}/$undata" && \
		unzip $undata && \
		rm -f $undata
		journal "sortie wget $undata : $?"
		continue
	done
	# BUG : il reste un répertoire A VOIR
	rm -f "data-programmes.zip"

	cd "${CHEMIN_COURANT}"
	journal "sortie ${FUNCNAME} : $?"
	}
function MaJpiKIL () {
journal "appel de : ${FUNCNAME}
	argument : ${@}"
	msgbox "TODO - lancement de : MaJpiKIL"
	journal "sortie ${FUNCNAME} : $?"
	}
function choisirTelechagements () {
journal "appel de : ${FUNCNAME}
	argument : ${@}"
	zenity --list \
		--checklist \
		--title="Téléchagement" \
		--text="" \
		--column="" --column="Mettre à jour" \
		FALSE "1- le programme piKIL" TRUE "2- les Datas"
	journal "sortie ${FUNCNAME} : $?"
	}
function telechargement () {
journal "appel de : ${FUNCNAME}
	argument : ${@}"
	local lesCHOIX
	local leCHOIX
	local unChoix

	lesCHOIX="$(choisirTelechagements)"
	# echo "lesCHOIX=$lesCHOIX"
	# [ -n $lesCHOIX ] && {
	IFS='|' leCHOIX=( $lesCHOIX )
	for unChoix in ${leCHOIX[@]}
	do
		case $unChoix in
			1-*) MaJpiKIL ;;
			2-*) MaJDesData ;;
			*) journal "erreur - sortie de telechargement \n$unChoix";;
		esac
	done
	# } || msgbox "erreur : lesCHOIX=$lesCHOIX"

	journal "sortie ${FUNCNAME} : $?"
	}
function installerPack () {
	journal "appel de : ${FUNCNAME}
	argument : ${@}"
	local CHEMIN_COURANT="${PWD}"
	cd "${CHEMIN_DES_MODULES}/" ;
	#~-----> "récupère le nom des tweaks (uniquement) du fichier tweaklist par ligne" ;
	while read leChemin 
	do
		if [ "$(ls "${CHEMIN_DES_MODULES}/$leChemin/" | grep "install.sh" ;)"="install.sh" ] ; then
			cd "$leChemin/" ;
			journal "leChemin : $leChemin"
			xterm -e "./install.sh" ;
			#~gnome-terminal -e "./install.sh" ;
			#~gnome-terminal --command "./install.sh" ;
			cd .. ;
		fi
	done < "${FICHIER_TWEAKLIST}" ;

	cd "${CHEMIN_COURANT}" ;
	journal "sortie ${FUNCNAME} : $?"
	}

#~**************************************************************
function choisirDossierModules () {
	journal "appel de : ${FUNCNAME}
	argument : ${@}"
	local le_titre="${txt_Select_Dossier}" ;
	local le_texte="${txt_Select_DossierInfos}
	${CHEMIN_DES_MODULES}" ;

	zenity --file-selection --directory \
	--filename="${CHEMIN_DES_MODULES}/" \
	--title="${le_titre}" \
	--text="${le_texte}" ;
	journal "sortie ${FUNCNAME} : $?"
	}
function parserFichierTweaklist () {
	journal "appel de : ${FUNCNAME}
	argument : ${@}"
	nbreArg=0 ;
	CHOIX_MODULES="" ;

	ls "${CHEMIN_DES_MODULES}/" | tee "${FICHIER_TWEAKLIST}" >/dev/null; #~avec toutes les options possibles

	#~cases de la prochaine liste cochées ?
	DEF_BOOL="TRUE" ; #~ou "FALSE"
	out=$(zenity --list \
		--radiolist \
		--title="Oui ou Non" \
		--text="cases de la prochaine liste cochées ? " \
		--column=choix --column=num --column=separateur \
		--print-column="2" \
		--hide-column="2" \
		TRUE 1 "oui" FALSE 2 "non")
	case $out in
		1 ) DEF_BOOL="TRUE" ;;
		2 ) DEF_BOOL="FALSE" ;;
		* ) journal "DEF_BOOL >> $out" ; exit 1 ;;
	esac

	while read ligne ; do
		if [ "$(ls "${CHEMIN_DES_MODULES}/${ligne}/" | grep "install.sh" ;)"="install.sh" ] ; 
		then
			nbreArg="$(expr $nbreArg + 1)" ;
			# (($nbreArg ++)) ;
			CHOIX_MODULES=$(echo "${CHOIX_MODULES}"${DEF_BOOL}"|${ligne}|") ;
		fi
	done < "${FICHIER_TWEAKLIST}" ;
	journal "sortie ${FUNCNAME} : $?"
	}
function selectionnerModules () {
	journal "appel de : ${FUNCNAME}
	argument : ${@}"
	local le_titre="$txt_Choisissez_Options" ;
	local le_texte="$txt_Select_Modules" ;

	zenity --list --separator="$IFS" \
	--width=500 --height=650 \
	--title="$le_titre" \
	--text "$le_texte" --checklist \
	--column "choix" --column "Valeur" \
	${CHOIX_MODULES} ;
	journal "sortie ${FUNCNAME} : $?"
	}
function ecrireTweaklistFile () {
	journal "appel de : ${FUNCNAME}
	argument : ${@}"
	# raz TweaklistFile
		echo -n > "${FICHIER_TWEAKLIST}" >/dev/null;
		# echo -n | tee "${FICHIER_TWEAKLIST}" ;
	for uneSelection in ${mesSelections} ; 
	do
		echo $uneSelection | tee -a "${FICHIER_TWEAKLIST}" >/dev/null;
	done
	journal "sortie ${FUNCNAME} : $?"
	}
function corriger_CHEMIN_DES_MODULES () {
	journal "appel de : ${FUNCNAME}
	argument : ${@}"
	if [ ${CHEMIN_DES_MODULES: -2} = "/0" ]; then
		CHEMIN_DES_MODULES="${CHEMIN_DES_MODULES%/*}" 
	#else 
		#CHEMIN_DES_MODULES="${CHEMIN_DES_MODULES}" ;
	fi
	journal "sortie ${FUNCNAME} : $?"
	}
function corriger_CHEMIN_DES_MODULES2 () {
journal "appel de : ${FUNCNAME}
CHEMIN_DES_MODULES=${CHEMIN_DES_MODULES}
	argument : ${@}"
leDossierTest="$(ls "${CHEMIN_DES_MODULES}/" | grep "install.sh" )"
	[ "$leDossierTest" = "install.sh" ] && {
		cd "${CHEMIN_DES_MODULES}"
		cd ..
		CHEMIN_DES_MODULES="${PWD}"
		cd "${PWD}"
	#~else 
		#~CHEMIN_DES_MODULES="${CHEMIN_DES_MODULES}" ;
	}
	journal "sortie ${FUNCNAME} : $?"
	}

#~**************************************************************
function creerTweaklist () {
journal "appel de : ${FUNCNAME}
	argument : ${@}"
	CHEMIN_DES_MODULES_new=$(choisirDossierModules) ;
	if [ ${#CHEMIN_DES_MODULES_new} -gt 0 ] ; then
		CHEMIN_DES_MODULES="${CHEMIN_DES_MODULES_new}"
		corriger_CHEMIN_DES_MODULES ; #~bug /0 en fin de sélection d'un dossier !
		corriger_CHEMIN_DES_MODULES2 #~au cas où l'utilisateur aurait choisi un dossier d'installation

		OLDIFS="$IFS" ; IFS='|' ;
		parserFichierTweaklist ;
		mesSelections="$(selectionnerModules)" ;
		#[ $? = 0 ] || _quitter ;
		[ $? = 0 ] && ecrireTweaklistFile ;
		IFS="$OLDIFS" ;
	fi
	journal "sortie ${FUNCNAME} : $?"
	}

#~**************************************************************
function FRM_PRINCIPALE_parser () {
journal "appel de : ${FUNCNAME}
	argument : ${@}"
	case $1 in 
		1) creerTweaklist ;;
		2) AfficherTweaklist ;;
		3) installerPack ;;
		# 7) telechargement ;;
		8) afficher_aide ;;
		# 0) ;;
		9) _quitter ;;
		*) ;;
	esac
	journal "sortie ${FUNCNAME} : $?"
	}

#~**************************************************************
function _main () {
	journal "appel de : ${FUNCNAME}
	argument : ${@}"
	menuchoice=$(FRM_PRINCIPALE);
	FRM_PRINCIPALE_parser ${menuchoice%|*} #~pour corriger le 1|1 de zenity

	#~on boucle _main ; pour sortir, faire choix quitter
	_main
	journal "sortie ${FUNCNAME} : $?"
	}

#~**************************************************************
#~LE SCRIPT COMMENCE ICI
_main
#~**************************************************************
#~le programme ne devrait pas passer par là !

exit 0

Dernière modification par kholo (Le 17/06/2017, à 10:44)

Hors ligne

#2 Le 12/09/2016, à 16:31

kholo

Re : [tuto bash]script lanceur de script et post install 16.04

On va maintenant créer des scripts pour la post installation de Ubuntu suivant mon post sur ma post installation de ubuntu 16.04
NB chaque script est indépendant et peut être lancer directement wink
1473763406.png

cd $HOME/bin/lanceur/
mkdir "PIU16.04-v0.11"
cd "PIU16.04-v0.11"

01 installer_francisation

mkdir "01 installer_francisation"
gedit "01 installer_francisation/install.sh"

copier / coller le code

#!/bin/bash
# ----------------------------------------------
# nomlogiciel="$(basename "$0")"
nomlogiciel="${0##*/}"
FONCTION="Ajout des packs langue française"
VERSION="alpha"
# NOTES DE VERSIONS
# ----------------------------------------------
leTexte="$FONCTION
continuer ?"
zenity --question --title="post installation Ubuntu 16.04" --text="$leTexte"
if [ $? -eq 0 ]
then
	echo "on continue"
else
	exit 1
fi

echo $FONCTION
sleep 2
sudo apt install language-pack-fr language-pack-fr-base language-pack-gnome-fr language-pack-gnome-fr-base

exit 0

puis le rendre exécutable

chmod +x "01 installer_francisation/install.sh"

Je vous passe la redondance des lignes de code
il faudra pour chaque script
1. créer un dossier dont je donnerai le nom vous pourrez le modifier par la suite
2. puis, dedans, un fichier install.sh
3. rendre le script exécutable
je donnerai plus d'explications pour les scripts "spéciaux"
(pour l'instant je n'en met pas)

01 MAJ - Mise à Jour

#!/bin/bash
# ----------------------------------------------
# nomlogiciel="$(basename "$0")"
nomlogiciel="${0##*/}"
FONCTION="MAJ SYSTEM"
VERSION="alpha"
# NOTES DE VERSIONS
# ----------------------------------------------
leTexte="$FONCTION

continuer ?"
zenity --question --title="post installation Ubuntu 16.04" --text="$leTexte"
if [ $? -eq 0 ]
then
	echo "on continue"
else
	exit 1
fi

# function MAJ {
# Mise à jour des paquets
sudo apt update
# Mise à jour des logiciels
sudo apt upgrade
# Mise à jour de la partie basse et noyau
sudo apt full-upgrade
# }
# MAJ

function Nettoyage {
# Nettoyage des paquets
sudo apt autoremove
}
# Nettoyage

exit 0

05 Configurer nautilus

#!/bin/bash
# ----------------------------------------------
# nomlogiciel="$(basename "$0")"
nomlogiciel="${0##*/}"
FONCTION="Customizer nautilus"
VERSION="alpha"
# NOTES DE VERSIONS
# ----------------------------------------------
leTexte="$FONCTION

continuer ?"
zenity --question --title="post installation Ubuntu 16.04" --text="$leTexte"
if [ $? -eq 0 ]
then
	echo "on continue"
else
	exit 1
fi

# function _main {
# gsettings set org.gnome.nautilus.preferences always-use-location-entry true
gsettings set org.gnome.nautilus.list-view use-tree-view true
gsettings set org.gnome.nautilus.preferences click-policy "'double'"
gsettings set org.gnome.nautilus.preferences default-folder-viewer "'list-view'"
gsettings set org.gnome.nautilus.preferences enable-delete false
gsettings set org.gnome.nautilus.preferences show-directory-item-counts 'never'
gsettings set org.gnome.nautilus.preferences thumbnail-limit 512000

gsettings set org.gnome.nautilus.preferences executable-text-activation ask
# Nautilus
# command gsettings set org.gnome.nautilus.list-view use-tree-view true
# command gsettings set org.gnome.nautilus.preferences default-folder-viewer 'list-view'
# command gsettings set org.gnome.nautilus.preferences show-image-thumbnails 'local-only'
gsettings set org.gnome.nautilus.preferences show-image-thumbnails 'local-only'
# command gsettings set org.gnome.nautilus.preferences sort-directories-first true
gsettings set org.gnome.nautilus.preferences sort-directories-first true

# }
# _main

exit 0

08 Désactiver mot de passe en sortant de veille

#!/bin/bash
# ----------------------------------------------
# nomlogiciel="$(basename "$0")"
nomlogiciel="${0##*/}"
FONCTION="Désactiver le mot de passe à la sortie de veille"
VERSION="alpha"
# NOTES DE VERSIONS
# ----------------------------------------------
leTexte="$FONCTION

continuer ?"
zenity --question --title="post installation Ubuntu 16.04" --text="$leTexte"
if [ $? -eq 0 ]
then
	echo "on continue"
else
	exit 1
fi

# function _main {
gsettings set org.gnome.desktop.lockdown disable-lock-screen 'true'
# }
# _main

exit 0

09 Desactiver suggestions d'achat

#!/bin/bash
# ----------------------------------------------
# nomlogiciel="$(basename "$0")"
nomlogiciel="${0##*/}"
FONCTION="Desactiver suggestions d'achat
-------------------------------------------------
ce script peut être lancé pour chaque utilisateur
il désactive les suggestions et donc l'envoie éventuel des informations associées
------------------------------------------------"
VERSION="alpha"
# NOTES DE VERSIONS
# ----------------------------------------------
leTexte="$FONCTION

continuer ?"
zenity --question --title="post installation Ubuntu 16.04" --width=500 --height=300 --text="$leTexte" --no-wrap
if [ $? -eq 0 ]
then
	echo "on continue"
else
	exit 1
fi

#Desactiver suggestions d'achat
command gsettings set com.canonical.Unity.Lenses disabled-scopes "['more_suggestions-amazon.scope', 'more_suggestions-u1ms.scope', 'more_suggestions-populartracks.scope', 'music-musicstore.scope', 'more_suggestions-ebay.scope', 'more_suggestions-ubuntushop.scope', 'more_suggestions-skimlinks.scope']"
command gsettings set 'com.canonical.Unity.ApplicationsLens' 'display-available-apps' 'false'

exit 0

20 numlock - Allumer pad numérique au démarrage

#!/bin/bash
# ----------------------------------------------
# nomlogiciel="$(basename "$0")"
nomlogiciel="${0##*/}"
FONCTION="Activer Numlock - le pad numérique
# Pour être certain que le pad numérique (numlock) est actif au démarrage"
VERSION="alpha"
# NOTES DE VERSIONS
# ----------------------------------------------
leTexte="$FONCTION

continuer ?"
zenity --question --title="post installation Ubuntu 16.04" --text="$leTexte"
if [ $? -eq 0 ]
then
	echo "on continue"
else
	exit 1
fi

# function InstallerNumlock {
# echo "InstallerNumlock"
# sudo apt install numlockx
# }
# InstallerNumlock

# function ActiverNumlock {
echo "ActiverNumlock"
sudo sed -i 's|^exit 0.*$|# Numlock enable\n[ -x /usr/bin/numlockx ] \&\& numlockx on\n\nexit 0|' /etc/rc.local
# }
# ActiverNumlock

exit 0

40 caffeine - activer ou désactiver l'économiseur d'écran

#!/bin/bash
# ----------------------------------------------
# nomlogiciel="$(basename "$0")"
nomlogiciel="${0##*/}"
FONCTION="Installer Caffeine"
VERSION="alpha"
# NOTES DE VERSIONS
# ----------------------------------------------
leTexte="$FONCTION

continuer ?"
zenity --question --title="post installation Ubuntu 16.04" --text="$leTexte"
if [ $? -eq 0 ]
then
	echo "on continue"
else
	exit 1
fi

function InstallerCaffeine {
# journal "Installer Caffeine"
# Permet de couper ou activer l'économiseur d'écran
sudo apt install caffeine
}

function Caffeine {
# journal "Caffeine"
# sera lancé automatiquement au prochain lancement de l'utilisateur
# (je l'utilise plutôt en extension sur Gnome 3)
# lancement manuel
caffeine-indicator &
}

InstallerCaffeine
Caffeine

zenity --info --text="caffeine sera actif au prochain démarrage"
exit 0

50 geany installation

#!/bin/bash
# ----------------------------------------------
# nomlogiciel="$(basename "$0")"
nomlogiciel="${0##*/}"
FONCTION="geany - installation et paramétrages"
VERSION="alpha"
# NOTES DE VERSIONS
# ----------------------------------------------
leTexte="$FONCTION

continuer ?"
zenity --question --title="post installation Ubuntu 16.04" --text="$leTexte"
if [ $? -eq 0 ]
then
	echo "on continue"
else
	exit 1
fi

# function _Install_geany {
# echo "Install geany"
sudo apt-get install geany
sudo apt-get install geany-plugins
# }
# _Install_geany

# function _configuration {

# }

# _configuration

exit 0

50 gedit parametrages

#!/bin/bash
# ----------------------------------------------
# nomlogiciel="$(basename "$0")"
nomlogiciel="${0##*/}"
FONCTION="Gedit - installation et paramétrages"
VERSION="alpha"
# NOTES DE VERSIONS
# ----------------------------------------------
leTexte="$FONCTION

continuer ?"
zenity --question --title="post installation Ubuntu 16.04" --text="$leTexte"
if [ $? -eq 0 ]
then
	echo "on continue"
else
	exit 1
fi

# function _Install_gedit {
# echo "Install gedit"
# sudo apt-get install gedit
# sudo apt-get install gedit-plugins
# }
# _Install_gedit

# function _configuration {
gsettings set org.gnome.gedit.preferences.editor auto-save false
gsettings set org.gnome.gedit.preferences.editor create-backup-copy false
gsettings set org.gnome.gedit.preferences.editor display-line-numbers true
gsettings set org.gnome.gedit.preferences.editor highlight-current-line true
gsettings set org.gnome.gedit.preferences.editor display-right-margin true
gsettings set org.gnome.gedit.preferences.editor scheme "'oblivion'"
gsettings set org.gnome.gedit.preferences.editor tabs-size 4
gsettings set org.gnome.gedit.preferences.editor auto-save false
gsettings set org.gnome.gedit.preferences.editor bracket-matching false
gsettings set org.gnome.gedit.preferences.editor create-backup-copy false
gsettings set org.gnome.gedit.preferences.editor display-line-numbers true
gsettings set org.gnome.gedit.preferences.editor display-right-margin true
gsettings set org.gnome.gedit.preferences.editor highlight-current-line true
gsettings set org.gnome.gedit.preferences.editor insert-spaces false
gsettings set org.gnome.gedit.preferences.editor scheme 'oblivion'
gsettings set org.gnome.gedit.preferences.editor wrap-mode 'none'
gsettings set org.gnome.gedit.preferences.editor tabs-size 4
gsettings set org.gnome.gedit.preferences.ui statusbar-visible true
# }

# _configuration

exit 0

60 installer google chrome

#!/bin/bash
# ----------------------------------------------
# nomlogiciel="$(basename "$0")"
nomlogiciel="${0##*/}"
FONCTION="installer google chrome"
VERSION="alpha"
# NOTES DE VERSIONS
# ----------------------------------------------
leTexte="$FONCTION
continuer ?"
zenity --question --title="post installation Ubuntu 16.04" --text="$leTexte"
if [ $? -eq 0 ]
then
	echo "on continue"
else
	exit 1
fi

# echo $FONCTION
# sleep 2
wget -q -O - https://dl-ssl.google.com/linux/linux_signing_key.pub | sudo apt-key add -
sudo sed -i -e 's/deb http/deb [arch=amd64] http/' "/etc/apt/sources.list.d/google-chrome.list"
sudo apt-get update
sudo apt-get install google-chrome-stable

exit 0

70 Unity configurer

#!/bin/bash
# ----------------------------------------------
# nomlogiciel="$(basename "$0")"
nomlogiciel="${0##*/}"
FONCTION="Configuration de Unity"
VERSION="alpha"
# NOTES DE VERSIONS
# ----------------------------------------------
leTexte="$FONCTION

continuer ?"
zenity --question --title="post installation Ubuntu 16.04" --text="$leTexte"
if [ $? -eq 0 ]
then
	echo "on continue"
else
	exit 1
fi

# function Unity_Features {
# Unity Features
command gsettings set com.canonical.Unity always-show-menus false
command gsettings set com.canonical.Unity.ApplicationsLens display-available-apps false
command gsettings set com.canonical.Unity.ApplicationsLens display-recent-apps false
command gsettings set com.canonical.Unity.Lenses remote-content-search none
command gsettings set com.canonical.Unity.Lenses disabled-scopes "[]"
command gsettings set com.canonical.indicator.power show-percentage true
command gsettings set com.canonical.indicator.power show-time true
command gsettings set com.canonical.unity-greeter background-color '#241916'
command gsettings set com.canonical.unity-greeter background '/usr/share/backgrounds/warty-final-ubuntu.png'
command gsettings set com.canonical.unity-greeter draw-grid true
command gsettings set com.canonical.unity-greeter draw-user-backgrounds true
command gsettings set com.canonical.unity-greeter font-name 'Ubuntu 11'
command gsettings set com.canonical.unity-greeter indicators ['ug-accessibility', 'com.canonical.indicator.keyboard', 'com.canonical.indicator.session', 'com.canonical.indicator.datetime', 'com.canonical.indicator.power', 'com.canonical.indicator.sound', 'application']
command gsettings set com.canonical.unity-greeter logo '/usr/share/unity-greeter/logo.png'
command gsettings set com.canonical.unity-greeter onscreen-keyboard false
command gsettings set com.canonical.unity-greeter play-ready-sound false
command gsettings set com.canonical.unity-greeter screen-reader false
command gsettings set com.canonical.Unity.ApplicationsLens display-available-apps false
command gsettings set com.canonical.Unity.ApplicationsLens display-recent-apps false
command gsettings set org.gnome.desktop.privacy remember-recent-files false
command gsettings set com.canonical.Unity home-expanded 'Expanded'

# }
# Unity_Features

exit 0

80 BootRepair installer

#!/bin/bash
# ----------------------------------------------
# nomlogiciel="$(basename "$0")"
nomlogiciel="${0##*/}"
FONCTION="Installer BootRepair"
VERSION="alpha"
# NOTES DE VERSIONS
# ----------------------------------------------
leTexte="$FONCTION

continuer ?"
zenity --question --title="post installation Ubuntu 16.04" --text="$leTexte"
if [ $? -eq 0 ]
then
	echo "on continue"
else
	exit 1
fi

# function InstallerBootRepair {
echo "BootRepair
# en cas de problème de démarrage et de disque dur, ce programme est providentiel..."
# vous pouvez faire un boot info que vous garderez de côté
sudo add-apt-repository ppa:yannubuntu/boot-repair && sudo apt update && sudo apt install boot-repair
# }
# InstallerBootRepair

exit 0

80 lm-sensors - installer et configurer

#!/bin/bash
# ----------------------------------------------
# nomlogiciel="$(basename "$0")"
nomlogiciel="${0##*/}"
FONCTION="Installer lmsensors
températures et sondes
installer et paramétrer le programme de détection"
VERSION="alpha"
# NOTES DE VERSIONS
# ----------------------------------------------
leTexte="$FONCTION

continuer ?"
zenity --question --title="post installation Ubuntu 16.04" --text="$leTexte"
if [ $? -eq 0 ]
then
	echo "on continue"
else
	exit 1
fi

function Installerlmsensors {
# journal "Installer lmsensors"
sudo apt install lm-sensors 
}
Installerlmsensors

# function Activerlmsensors {
# pour détecter les sondes
sudo sensors-detect
# }
# Activerlmsensors

# voir les sondes
sensors

exit 0

50 radios sur le bureau simple

#!/bin/bash
# ----------------------------------------------
# nomlogiciel="$(basename "$0")"
nomlogiciel="${0##*/}"
FONCTION="Radios, Création d'un raccourci vers fichiers de listes lectures de radios"
VERSION="alpha"
# NOTES DE VERSIONS
# ----------------------------------------------
leTexte="$FONCTION

continuer ?"
zenity --question --title="post installation Ubuntu 16.04" --text="$leTexte"
if [ $? -eq 0 ]
then
	echo "on continue"
else
	exit 1
fi

RadiosDir="$HOME/Radios"
RadiosFile="$RadiosDir/radios.m3u8"

mkdir $RadiosDir

echo "#EXTM3U
#EXTINF:0,/tsfjazz - TSF Jazz
http://broadcast.infomaniak.net/tsfjazz-high.mp3
#EXTINF:0,rtl - RTL [MP3 64]
http://streaming.radio.funradio.fr/rtl-1-44-96
#EXTINF:0,rtl2 - RTL2 [MP3 128]
http://streaming.radio.funradio.fr/rtl2-1-44-128
#EXTINF:0,funradio - FUN [MP3 128]
http://streaming.radio.funradio.fr/fun-1-44-128
#EXTINF:0,Radio Classique
http://broadcast.infomaniak.net:80/radioclassique-high.mp3
#EXTINF:0,floydstory - ShineOnRadio
http://streaming.radionomy.com/floydstory?ad=radionoweb
#EXTINF:0,4U Classic Rock
http://str4uice.streamakaci.com/4uclassicrock.mp3
#EXTINF:0,4U70s
http://listen.radionomy.com/4u-70s
#EXTINF:0,PinkFloydTeGuz - GratefuleDRadio
http://streaming202.radionomy.com:80/pinkfloydteguz
#EXTINF:0,Acidbarrett - acidbarrett
http://streaming.radionomy.com/acidbarrett?ad=radionoweb
#EXTINF:0,Best80France - Best80France
http://streaming202.radionomy.com:80/Best80France
#EXTINF:0,[RELAY2] - Bide&Musique - variete alternative francophone 60-70-80 - alternate french oldies - live from Paris France 24h/24 - no ads
http://relay2.bide-et-musique.com:9100
" > "$RadiosFile"
ln -s "$RadiosFile" "$HOME/Bureau/"

exit 0

Dernière modification par kholo (Le 17/06/2017, à 10:43)

Hors ligne

#3 Le 16/09/2016, à 15:12

bigoud92

Re : [tuto bash]script lanceur de script et post install 16.04

Bonsoir kholo merci pour ce petit tuto fort sympathique lol je cherche depuis un petit moment des systèmes d’apprentissage du bash comme le tiens, je suis très spécial en matière de cours j'ai besoin d'exemple concret et la c'est pille poile ce qu'ils me faut pour assimiler un peut la logique qu'il faut avoir pour scripter... Bref beau travaille continue comme ça !!!! cool cool


Amateur d'Ubuntu depuis 2009 je suis novice mais je me soigne, et je suis animateur de podcast débutant l'apéro des papas manchots
PC portable sony vaio ubuntu 16.04 64bits : Intel® Core™ i5-2410M CPU @ 2.30GHz , 4GB ram
Ma chaîne youtube : http://www.youtube.com/c/johnguecko
Mon site wordpress: http://www.johnguecko.wordpress.com

Hors ligne

#4 Le 16/09/2016, à 16:07

Rufus T. Firefly

Re : [tuto bash]script lanceur de script et post install 16.04

Je ne sais pas si tu connais déjà : la bible de bash

Dernière modification par Rufus T. Firefly (Le 16/09/2016, à 16:08)


La provocation est une façon de remettre la réalité sur ses pieds. (Bertolt Brecht)
Il n'y a pas de route royale pour la science et ceux-là seulement ont chance d'arriver à ses sommets lumineux qui ne craignent pas de se fatiguer à gravir ses sentiers escarpés. (Karl Marx)
Il est devenu plus facile de penser la fin du monde que la fin du capitalisme

Hors ligne

#5 Le 16/09/2016, à 21:13

metalux

Re : [tuto bash]script lanceur de script et post install 16.04

En complément de ce tuto, voici un lien qui peut aider les débutants: http://aral.iut-rodez.fr/fr/sanchis/enseignement/bash/
Pour ma part, je ne comprenais pas grand chose à la bible de bash conseillé par Rufus T. Firefly alors que le document de Eric Sanchis m'a été accessible....ce n'est qu'après que j'ai compris l'intérêt du "Guide avancé d'écriture des scripts Bash" qui s'avère en effet indispensable, mais à mon avis,  pas pour débuter.

Hors ligne

#6 Le 17/09/2016, à 13:02

bigoud92

Re : [tuto bash]script lanceur de script et post install 16.04

metalux a écrit :

En complément de ce tuto, voici un lien qui peut aider les débutants: http://aral.iut-rodez.fr/fr/sanchis/enseignement/bash/
Pour ma part, je ne comprenais pas grand chose à la bible de bash conseillé par Rufus T. Firefly alors que le document de Eric Sanchis m'a été accessible....ce n'est qu'après que j'ai compris l'intérêt du "Guide avancé d'écriture des scripts Bash" qui s'avère en effet indispensable, mais à mon avis,  pas pour débuter.

Merci pour ce tuto en effets j'ai déjà vu le guide avancée d'écriture des scripts bash mais comme son nom l'indique il s'adresse il me semble être destinée au personne ayant déjà des connaissance en programmation ou du moins sur la méthode de "réflexion" a avoir pour appliquer les exemple et les adaptées a nos besoins. Je les garde dans un coin pour une lecture un peut plus approfondies quand j'aurais du temps. Merci à vous tous de partager votre envie d'apprendre et d'enseigner au jeunes manchots débutant comme moi smile wink


Amateur d'Ubuntu depuis 2009 je suis novice mais je me soigne, et je suis animateur de podcast débutant l'apéro des papas manchots
PC portable sony vaio ubuntu 16.04 64bits : Intel® Core™ i5-2410M CPU @ 2.30GHz , 4GB ram
Ma chaîne youtube : http://www.youtube.com/c/johnguecko
Mon site wordpress: http://www.johnguecko.wordpress.com

Hors ligne

#7 Le 17/09/2016, à 19:02

kholo

Re : [tuto bash]script lanceur de script et post install 16.04

Hors ligne

#8 Le 29/05/2017, à 12:13

kholo

Re : [tuto bash]script lanceur de script et post install 16.04

bonjour à ceux qui suivent ;
j'ai mis le script et les fichiers de config du lanceur ainsi que quelques exemples dans cette archive
edit : fin de vie de l'archive

Dernière modification par kholo (Le 24/10/2017, à 11:55)

Hors ligne

#9 Le 17/06/2017, à 08:17

kholo

Re : [tuto bash]script lanceur de script et post install 16.04

SWAP Gestion des valeurs
pour voir les valeurs actuelles

cat /proc/sys/vm/swappiness
cat /proc/sys/vm/vfs_cache_pressure

les valeurs par défaut sont dans le script

# adapter avec les valeurs souhaitées ici
mySwap=5
mycache=50

les valeurs sont prises en compte après un redémarrage ou en relançant le service de swap

sudo swapoff -a
sudo swapon -a
#!/bin/bash
# ----------------------------------------------
NOM_DU_LOGICIEL="${0##*/}"
FONCTION="Configurer swappiness et CachePressureSettings"
VERSION="alpha"
# NOTES DE VERSIONS
# kholo-informatique
# A VOIR
# https://dolys.fr/forums/topic/mon-installation-post-installation-manjaro/
# echo vm.vfs_cache_pressure=50 | sudo tee /etc/sysctl.d/99-swappiness.conf
# sudo sysctl -p /etc/sysctl.d/99-swappiness.conf
# ----------------------------------------------
leTexte="$FONCTION

continuer ?"
zenity --question --title="post installation Ubuntu 16.04" --text="$leTexte"
if [ $? -eq 0 ] ; then echo "on continue" ; else exit 1 ; fi

# function _initialisation {
# echo "*******************initialisation*******************"
# echo "VARIABLES"
sysctlconf_file="/etc/sysctl.conf"

# ATTENTION POUR DEBUGGUAGE (voir fin) 
# sysctlconf_file="test_sysctl.conf"

######################################################
# pour voir les valeurs actuelles
# cat /proc/sys/vm/swappiness
# cat /proc/sys/vm/vfs_cache_pressure

# adapter avec les valeurs souhaitées ici
mySwap=5
mycache=50
######################################################
# }
# _initialisation

# valeur dans "$sysctlconf_file"
# on sort les lignes du fichiers qui conscernent les vm.
lignes_swappiness="$(cat "$sysctlconf_file" | grep "vm.swappiness")"
lignes_vfs_cache_pressure="$(cat "$sysctlconf_file" | grep "vm.vfs_cache_pressure")"

# echo "---------------------------
# VERIFICATIONS
# lignes_swappiness $lignes_swappiness
# ---------------------------
# lignes_vfs_cache_pressure $lignes_vfs_cache_pressure
# ---------------------------"
# exit 0

######################################################
function modifierSwappiness {
	# echo $1
	qteSwappiness="${1#*=}"
	# echo "qteSwappiness=$qteSwappiness"
	[ $mySwap -eq $qteSwappiness ] || {
		RECHERCHE=$1
		REMPLACEMENT="vm.swappiness=$mySwap"
		FICHIER="$sysctlconf_file"
		# echo "# sudo sed -i -e s/$RECHERCHE/$REMPLACEMENT/g $FICHIER"
		sudo sed -i -e "s/$RECHERCHE/$REMPLACEMENT/g" "$FICHIER"
		echo "--------------- $FICHIER modifié ---------------"
		}
}
######################################################
function modifierCache_pressure {
	# echo $1
	qteCache_pressure="${1#*=}"
	# echo "qteCache_pressure=$qteCache_pressure"
	[ $mycache -eq $qteCache_pressure ] || {
		RECHERCHE=$1
		REMPLACEMENT="vm.vfs_cache_pressure=$mycache"
		FICHIER="$sysctlconf_file"
		# echo "# sudo sed -i -e s/$RECHERCHE/$REMPLACEMENT/g $FICHIER"
		sudo sed -i -e "s/$RECHERCHE/$REMPLACEMENT/g" "$FICHIER"
		echo "--------------- $FICHIER modifié ---------------"
		}
}
######################################################
# on utilise les sauts de lignes 
# pour parser le fichier et trouver les lignes correspondantes
# oldIFS=$IFS
IFS=$'\n'
if [ -z "$lignes_swappiness" ] ; then
	echo "pas trouvé : vm.swappiness - ajout de la ligne"
	echo "# ajout automatique $0 - $(date +%D-%R)" | sudo tee -a "$sysctlconf_file"
	echo "vm.swappiness=$mySwap" | sudo tee -a "$sysctlconf_file"
else
	for i in $lignes_swappiness ; do
		echo "--------modifier Swappiness $i"
		[ ${i:0:1} == '#' ] || modifierSwappiness "$i"
	done
fi
# idem pour vfs_cache_pressure
if [ -z "$lignes_vfs_cache_pressure" ] ; then
	echo "pas trouvé : vm.vfs_cache_pressure - ajout de la ligne"
	echo "# ajout automatique $0 - $(date +%D-%R)" | sudo tee -a "$sysctlconf_file"
	echo "vm.vfs_cache_pressure=$mycache" | sudo tee -a "$sysctlconf_file"
else
	for j in $lignes_vfs_cache_pressure ; do
		echo "--------modifier Cache_pressure $j"
		[ ${j:0:1} == '#' ] || modifierCache_pressure "$j"
	done
fi
# IFS="$oldIFS"

# ATTENTION POUR DEBUGGUAGE
# sudo chown $USER "$sysctlconf_file"

exit 0

Dernière modification par kholo (Le 17/06/2017, à 10:28)

Hors ligne

#10 Le 17/06/2017, à 10:25

erresse

Re : [tuto bash]script lanceur de script et post install 16.04

Bonjour kholo,
Je me permet de te signaler une erreur que tu fais dans tous tes scripts : lorsque tu écris une ligne

zenity --question --text="post installation Ubuntu 16.04" --text="$leTexte"

Tu devrais mettre

zenity --question --title="post installation Ubuntu 16.04" --text="$leTexte"

car il ne peut y avoir deux indications différentes dans le même champ --text...
Sinon, bravo pour ton initiative, à la fois utile et formatrice.
Continue !
smile


Plus de 50 ans d'informatique, ça en fait des lignes de commandes en console, mais on n'avait pas le choix...
Excellente raison pour, aujourd'hui qu'on le peut, utiliser au maximum les INTERFACES GRAPHIQUES !
Important : Une fois résolu, pensez à clore votre sujet en ajoutant [Résolu] devant le titre du 1er message, et un bref récapitulatif de la solution à la fin de celui-ci. Merci.

Hors ligne

#11 Le 17/06/2017, à 10:28

kholo

Re : [tuto bash]script lanceur de script et post install 16.04

ouiiii, merci erresse, à chaque fois je me dis que je devrais corriger...
je le fais de ce pas !!!
merci pour les encouragements ! wink

Hors ligne

#12 Le 17/06/2017, à 10:56

kholo

Re : [tuto bash]script lanceur de script et post install 16.04

une splash screen en bash !
mettre une image, adapter la ligne de conf :

set "images/debian.png"

et lancer
NB : cette fenêtre se ferme au bout de 2 secondes (--timeout=2)

#!/bin/bash
# ----------------------------------------------
nomlogiciel="${0##*/}"
FONCTION="faire apparaître et fermer automatiquement une splach screen"
VERSION="alpha"
# NOTES DE VERSIONS
# ----------------------------------------------
# 
# ----------------------------------------------
echo "lancement $nomlogiciel..." ;

# adapter ici l'emplacement de l'image
# ici un sous dossier images et une image : debian.png
set "images/debian.png"
duTexte="les splash screen c'est cool !"

(echo "<h1>$duTexte</h1><img src=\"data:"
 mimetype -b "$1"
 echo -n ";base64,"
 base64 "$1"
 echo "\">") | zenity --text-info --timeout=2 --width=400 --height=500 --ok-label="Go" --cancel-label="aurez-vous le temps ? >>>>" --html --filename=/dev/stdin

# zenity --text-info --html --filename=/dev/stdin # VERSION SIMPLE !
exit 0

Hors ligne

#13 Le 31/07/2017, à 13:40

Compte anonymisé

Re : [tuto bash]script lanceur de script et post install 16.04

Franchement c'est un travail exemplaire ci il y avait plus de gens comme toi sur le forum ! Moi je te remercie pour ton excellent travail j'ai vue tes vidéos aussi pour trouvé plus expliquatif est plus simple on ne peu pas merci pour tout ! Le pc a kiki va bien ? smile

#14 Le 01/08/2017, à 09:27

kholo

Re : [tuto bash]script lanceur de script et post install 16.04

merci,
LES PC à kiki vont bien... enfin le logiciel...
pour le reste, rassure toi, ce n'est pas moi qui fait le forum (on est quelques uns )
et chacun fait à son rythme et à son niveau...
... et ya d' la matière pour qui sait chercher ou demander cool !!!

Hors ligne

#15 Le 01/08/2017, à 11:10

Compte anonymisé

Re : [tuto bash]script lanceur de script et post install 16.04

Je te rassures je li beaucoup mais je pense qu'un petit merci n'est jamais en trop ! Pour des gens qui ce donne la peine
Ps: ça ne date pas d'hier que je te li est que je suis le forum même ci mon inscription est récente wink

Dernière modification par Compte anonymisé (Le 01/08/2017, à 11:28)

#16 Le 01/08/2017, à 11:41

kholo

Re : [tuto bash]script lanceur de script et post install 16.04

cool

Hors ligne

#17 Le 25/10/2017, à 09:37

kholo

Re : [tuto bash]script lanceur de script et post install 16.04

lanceur de script (sans utiliser zenity) :
Comme la version précédente du post #1, l’intérêt est de ne travailler ensuite que sur des "patchs" à mettre dans des dossiers avec un lanceur spécifique (main.pil ou lanceur.sh)
c'est le script qui crée le menu à partir de l'arborescence qu'on lui donne...
la liste de chaque page n'aura que 10 point, si il existe plus de 10 point des pages sont créées et accessible avec les touches S et p pour suivant précédent...
il faut valider chaque chois avec la touche "entrer"
je met en dessous la version v0.010
kipilUbuntu
pour le lancer

kipilUbuntu "/un/dossier/data/"
NB a écrit :
kipilUbuntu

lance la démo (mais il faut un sous dossier data_demo à créer)

avec "/un/dossier/data/" (tout en dossier sauf main.pil)

catégorie 01
	patch A
		main.pil (ou install.sh)
	patch B
		main.pil (ou install.sh)
	patch C
		main.pil (ou install.sh)
	...
catégorie 02
	patch D
		main.pil (ou install.sh)
	patch E
		main.pil (ou install.sh)
	patch F
		main.pil (ou install.sh)
	...
catégorie 03
...

pour cet exemple mettre dans les "main.pil"

#!/bin/bash
# ----------------------------------------------
nomlogiciel="${0##*/}"
FONCTION=""
VERSION="alpha"
# NOTES DE VERSIONS
# ----------------------------------------------
# 
# ----------------------------------------------
# mon lanceur est ici et peut être un script où un lien vers le script à lancer
echo "lancement $nomlogiciel...
vous êtes à \n$PWD
dans $0
à la ligne $LINENO"

exit 0
#!/bin/bash
# ----------------------------------------------
nomlogiciel="${0##*/}"
FONCTION="lanceur de scripts ; installeurs, patchs, ppa,..."
VERSION="0.010"
# NOTES DE VERSIONS
# ----------------------------------------------
# 
# ----------------------------------------------
echo "lancement $nomlogiciel..."
sleep .5
clear

# ****************************************************************

# nautilus "$PWD" ; exit 0

# Pour éviter d'accéder en lecture à une variable n'ayant pas d'existence, 
# on peut inscrire la commande set -u en début de script.
# set -u

# pour tracer demasquer set -x
# set -x

#~**************************************************************
#~l'utilisateur est il sudoer ?
#~**************************************************************
#~echo "l'utilisateur est il sudoer ?"
#~[ -n "$( groups $USER | grep sudo )" ] && echo oui || echo non
[ -n "$( groups $USER | grep sudo )" ] || {
echo "ATTENTION
ce script est lancé par $USER qui n'est pas sudoer 
et ne pourra pas exécuter certaines fonctions"
# exit 1
}
#~**************************************************************
# msgbox () { zenity --info --text="$@" ; }

# ****************************************************************

# initialiser_variables () {
# COULEURS

fdNoir='\033[40m'
fdRouge='\033[41m'
fdVert='\033[42m'
fdJaune='\033[43m'
fdBleu='\033[44m'
fdRose='\033[45m'
fdCyan='\033[46m'
fdGris='\033[47m'
# fdDefaut='\033[49m'

enNoir='\033[30m'
enRouge='\033[31m'
enVert='\033[32m'
enJaune='\033[33m'
enBleu='\033[34m'
enRose='\033[35m'
enCyan='\033[36m'
enGris='\033[37m'
# enDefaut='\033[39m'

enGras='\033[1m'
enSouligner='\033[4m'
enClignotant='\033[5m'
enSurligner='\033[7m'
enCache='\033[8m'

enDefaut='\033[0m'

# ****************************************************************

# GENERALES
# les_cat=""
START=$(date +%s.%N)
la_pageCAT=1
la_pagePATCH=1

tete_de_page="${enJaune}${enGras}-------------------------------------------
${enRouge}${enGras}$nomlogiciel v $VERSION
${enJaune}${enGras}-------------------------------------------"
pied_de_page="
${enVert}${enGras}p ${enJaune}${enGras}: précédent\t\t\t\
${enVert}${enGras}s ${enJaune}${enGras}: suivant
${enJaune}${enGras}-------------------------------------------
${enVert}${enGras}a ${enJaune}${enGras}: aide
${enRouge}${enGras}c ${enJaune}${enGras}: changer la catégorie
${enRouge}${enGras}q ${enJaune}${enGras}: quitter
${enJaune}${enGras}-------------------------------------------
${enJaune}${enGras}votre choix :${enDefaut}"

	# }
# initialiser_variables # FIN

# ******************************************************************

# splashScreen () {
echo -e "${enJaune}${enGras}
MMMMMMMMMMMMMMMMMMMMMMMNNMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
MMMMMMMMMMMMMMMMMMMMX:   .:NMMMMWXKKKKNMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
MMMMMMMMMMMMMMMMMMMM'      ;Mk'        lMMkkWMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
MMMMMMMMMMMMMMMMMMMMl      dW.        .WMx   ,0MMMMMMMMMMMMMMMMMMMMMMMMMMMMM
MMMMMMMMMMMMMMMMMMMMMKo::oKO'         KMX      ,KMMMMMMMMMMMMMMMMMMMMMMMMMMM
MMMMMMMMMMMMMMMMMMMMMNc::,.   .lOXWMMMMMx.       oMMMMMMMMMMMMMMMMMMMMMMMMMM
MMMMMMMMMMMMMMMMMMMMW'      ,KMMMMMMMMMMMWx.     oWd'..,dMMMMMMMMMMMMMMMMMMM
MMMMMMMMMMMMMMMMMMMMc      oMMMMMMMMMMMMMMMW,   ;M'      cMMMMMMMMMMMMMMMMMM
MMMMMMMMMMMMMMMMMMMN      ,MMMMMMMMMMMMMMMMMW.  ;M'      cMMMMMMMMMMMMMMMMMM
MMMMMMMMMMMMMMMMMMMK     .kMMMMMMMMMMMMMMMMMM;   lNd,..,xMMMMMMMMMMMMMMMMMMM
MMMMMMMMMMMMMMMMMMMWO0XWMMMMMMMMMMMMMMMMMMMMM.     oMMMMMMMMMMMMMMMMMMMMMMMM
MMMMMMMMMMMMMMMMMMMM0l:;'..xMMMMMMMMMMMMMMMMc      oMMMMMMMMMMMMMMMMMMMMMMMM
MMMMMMMMMMMMMMMMMMMMX.      cNMMMMMMMMMMMMMc      'WMMMMMMMMMMMMMMMMMMMMMMMM
MMMMMMMMMMMMMMMMMMMMMX.       ;xKWMMMMW0d0MWl    ,WMMMMMMMMMMMMMMMMMMMMMMMMM
MMMMMMMMMMMMMMMMMMMMMMWl          ...     ;XMX, dMMMMMMMMMMMMMMMMMMMMMMMMMMM
MMMMMMMMMMMMMMMMMMMMMMMMXc.:oddc'           lWMWMMMMMMMMMMMMMMMMMMMMMMMMMMMM
MMMMMMMMMMMMMMMMMMMMMMMMMMNo'..:OX,      .,o0MMMMMMMMMMMMWMMMMMMMMWNMMMMMMMM
MMX00000000XMMW0000000KMMM.      xW;;:cok0000XMMMMMMMMMX. :MMMMWO; 'MMMMMMMM
MMKx:    :xKMMWk;   .lOMMM.      xWkx.     .   'xMMMMMMk  .MMM0;.  'MMMMMMMM
MMMMM,  ,MMMMMMMd  dMMMMMMNl'..;OMMMMK   0MMWx.  'NMMMMMdc0MMMMMK  'MMMMMMMM
MMMMMc  cMMMMMMO .XMMMMMMMMMMMMMMMMMMW   KMMMMX   .WMMMMMMMMMMMMN  'MMMMMMMM
MMMMMc  cMMMMMd :WMMMMMMMMMMMMMMMMMMMM   KMMMMMl   kMMMMMMMMMMMMN  'MMMMMMMM
MMMMMc  cMMMW; oMMMMMMMMMMMMMMMMMMMMMM   KMMMMMk   oMMMMMMMMMMMMN  'MMMMMMMM
MMMMMc  cMMK. OMMMMMMMMMMMMMOc.oMMMMMM   KMMMMMk   dMMMKl.,MMMMMN  'MMMMMMMM
MMMMMc  cMx .XMMMMMMMMMMMMk'   lMMMMMM   KMMMMM,   NM0,   ,MMMMMN  'MMMMMMMM
MMMMMc  ;; .NMMMMMMMMMMMMMMMo  lMMMMMM   KMMMWc   kMMMMO  ,MMMMMN  'MMMMMMMM
MMMMMc  .   .XMMMMMMMMMMMMMMk  lMMMMMM   ':c:.  '0MMMMMN  ,MMMMMN  'MMMMMMMM
MMMMMc  cO    OMMMMMMMMMMMMMk  lMMMMMM   O0kxxONMMMMMMMN  ,MMMMMN  'MMMMMMMM
MMMMMc  cMX.   oMMMMMMMMMMMMk  lMMMMMM   KMMMMMMMMMMMMMN  ,MMMMMN  'MMMMMMMM
MMMMMc  cMMN,   ;WMMMMMMMMMMk  lMMMMMM   KMMMMMMMMMMMMMN  ,MMMMMN  'MMMMMMMM
MMMMMc  cMMMMo   .XMMMMMMMMMk  lMMMMMM   KMMMMMMMMMMMMMN  ,MMMMMN  'MMMMMMMM
MMMMMc  cMMMMMO.   OMMMMMMMMk  lMMMMMM   KMMMMMMMMMMMMMN  ,MMMMMN  'MMMMMMMM
MMMMM:  cMMMMMMX.   oWMMMMMMk  lMMMMMW   KMMMMMMMMMMMMMN  ,MMMMMN  'MMMMMMMM
MMMMM'  ,MMMMMMMX    .0MMMMMx  cMMMMMK   xMMMMMMMMMMMMMK  .MMMMMK  .MMMMMMMM
MMOo,    ,oOMMMO;      .ckKo.   cOWdl.    ldXMMMMMMMMNo.   :kMNd.   :dWMMMMM
MMNXXXXXXXXNMMMNXXXXXXXXXNWXXXXXXNMXXXXXXXXXWMMMMMMMMWXXXXXXXMWXXXXXXXMMMMMM
MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
$nomlogiciel v $VERSION"
	# }
# splashScreen
# sleep 1.2
sleep 3
# pause

# ****************************************************************

# JOURNAL

initialiser_journal () {
	fichier_log="$nomlogiciel.log"
	# #[ ! -f "$fichier_log" ] && \#
	> "$fichier_log"; 
	journal "*******************initialisation*******************"
	journal "chargement"
	}
journal () {
	local NOW=$(date +%s.%N)
	local DIFF=$(echo "${NOW} - ${START}" | bc)
	echo -e "[${DIFF}] ------------------\n${@}" >> "${fichier_log}"
	# echo -e "$@" >> "$fichier_log"
	}
initialiser_journal

# ****************************************************************

# FONCTIONS

# echo "chargement ligne $LINENO"
string_to_int (){
	LANG=C
	printf %.0f ${1/,/.}
	}

_quitter () {
	journal "appel de : ${FUNCNAME} ${@}"
	# mettre ici tout ce qui sera nescessaire à la bonne fermeture
	# ...
	exit 0
	}
# echo "chargement ligne $LINENO"
pause () {
	echo -e "${enVert}${enGras}Appuyer sur une touche pour continuer..."
	read -s -n 1
	}
# echo "chargement ligne $LINENO"
on_clear_terminal () {
	echo "${enDefaut}"
	reset > /dev/null
	}

# ****************************************************************

# PARTIE CATEGORIE

# echo "chargement ligne $LINENO"
choisir_dossier_DATA () {
	journal "appel de : ${FUNCNAME} ${@}"

	# dir_DATA=./data/
	# dir_DATA=./data_test/
	# dir_DATA="$( realpath "$dir_DATA" )"
	# #dir_DATA="$( readlink -e "$dir_DATA" )"
	# #dir_DATA="$( readlink -m "$dir_DATA" )"

	dir_DATA="$( realpath ./data_demo/ )"
	[[ -n ${@} ]] && dir_DATA="${@}"
	
	if [[ ! -d "$dir_DATA" ]]
	then 
		journal "erreur :\ndossier DATA : $dir_DATA" ; 
		exit 1 ; 
	fi
	journal "dossier DATA : $dir_DATA"
	}
# echo "chargement ligne $LINENO"
charger_categories () {
	journal "appel de : ${FUNCNAME} ${@}"
	les_cat=$(find "$dir_DATA" -maxdepth 1 -type d | sort)
	IFS=$'\n' les_cat=( $les_cat )
	# IFS=$'\n' 
	nbre_cat=${#les_cat[@]}

	nbre_page_cat=$(( 1+$nbre_cat/9 ))
	journal "nbre cats : $nbre_cat\nnbre pages : $nbre_page_cat"
	}


# echo "chargement ligne $LINENO"
afficherMenuCAT () {
	# journal "appel de : ${FUNCNAME} ${@}"
	multiCAT=$1
	echo -e "$tete_de_page"
	echo -e "${enJaune}CATEGORIES - ${enGras}page $multiCAT/$nbre_page_cat\n"

	for (( i=$(string_to_int $(($multiCAT-1))0); i<=$(string_to_int $(($multiCAT-1))9); i++ ))
	do
		[ -n "${les_cat[$i]}" ] && [ $i -ne 0 ] && echo -e "${enVert}${enGras}$i ${enJaune}${enGras}: ${les_cat[$i]##*/}"
	done
	# echo -e "${enJaune}${enGras}-------------------------------------------"
	echo -e "$pied_de_page"
	}
# echo "chargement ligne $LINENO"
page_suivanteCAT () {
	# journal "appel de : ${FUNCNAME} ${@}"
	if [ $la_pageCAT -lt $nbre_page_cat ] ; then let la_pageCAT++ ; fi
	}
# echo "chargement ligne $LINENO"
page_precedenteCAT () {
	# journal "appel de : ${FUNCNAME} ${@}"
	if [ $la_pageCAT -gt 1 ] ; then let la_pageCAT-- ; fi
	}
# echo "chargement ligne $LINENO"
parserChoixCAT () {
	# journal "appel de : ${FUNCNAME} ${@}"
	case "$choixCAT" in
		0) 
			journal "choixCAT=${choixCAT}\nTODO : choisir une cat" ; 
			echo "# rien à faire encore avec les 0 des CAT ;°)"
			sleep 2
			# pause ; 
			# mainCAT 
			;;

		[1-9]|[0-9][0-9]) 
			journal "choixCAT=${choixCAT}\n${les_cat[$choixCAT]}"
			la_cat="${les_cat[$choixCAT]}"
			choisir_dossier_PATCH "$la_cat"
			charger_patch
			mainPATCH
			pause
			;;

		c|C) mainCAT ;;

		s|S) page_suivanteCAT ;;
		p|P) page_precedenteCAT ;;

		a|A) _aide  ; pause ;;
		q|Q) _quitter ;;
		*)  ;;
	esac
	
	}
# echo "chargement ligne $LINENO"
mainCAT () {
	la_pagePATCH=1
	# journal "appel de : ${FUNCNAME} ${@}"
	on_clear_terminal
	afficherMenuCAT $la_pageCAT

	# #saisie du choixCAT
	# read -s -n 1 choixCAT 
	read -r choixCAT 

	on_clear_terminal
	parserChoixCAT
	mainCAT
	}

_aide () {
echo -e "POST INSTALLATION UBUNTU - Le PC à Kiki

Suite à ce tuto initialement posté sur le forum de Ubuntu fr
https://forum.ubuntu-fr.org/viewtopic.php?id=1993089

transcription en script bash.

Principe :
Le script principal n'est qu'un luncheur qui recense les dossiers 
contenus dans un dossier data 
ET qui contiennent des lanceurs eux même en bash 

Chaque lanceur peut être lancé indépendement sans dépendance.

Utilisation :
lancer $0 (pas de droits élevés)
$0
choisir une catégorie
lancer un patch à appliquer
donner le mot de passe root pour chaque nouvelle action
si celui ci est demandé.



TODO installation des dépendances :
la totalité des pgms utilisés doivent faire parti du système ou de bash :
cd, sed, echo, function,..."
	}

# ****************************************************************

# PARTIE PATCH

# echo "chargement ligne $LINENO"
choisir_dossier_PATCH () {
	# journal "appel de : ${FUNCNAME} ${@}"
	# dir_PATCH="$dir_DATA/00tests/"
	dir_PATCH="$@"
	# dir_PATCH="$dir_DATA/sudoer/"
	
	journal "dossier PATCH\n$dir_PATCH"
	}
# echo "chargement ligne $LINENO"
charger_patch () {
	# journal "appel de : ${FUNCNAME} ${@}"
	les_patch=$(find "$dir_PATCH" -maxdepth 1 -type d | sort)
	# les_patch="$@"
	IFS=$'\n' les_patch=( $les_patch )
	nbre_patch=${#les_patch[@]}
	nbre_page_patch=$(( 1+$nbre_patch/9 ))

	# msgbox "dir_PATCH=$dir_DATA/$@/
	# nbre_patch=$nbre_patch\nnbre_page_patch=$nbre_page_patch
	# "

	journal "nbre_patch=$nbre_patch\nnbre_page_patch=$nbre_page_patch"
	# pause
	}


# echo "chargement ligne $LINENO"
afficherMenuPATCH () {
	# journal "appel de : ${FUNCNAME} ${@}"
	multiPATCH=$1
	echo -e "$tete_de_page"
	echo -e "PATCHS - page $multiPATCH/$nbre_page_patch\n"

	for (( i=$(string_to_int $(($multiPATCH-1))0); i<=$(string_to_int $(($multiPATCH-1))9); i++ ))
	do
		[ -n "${les_patch[$i]}" ] && [ $i -ne 0 ] && echo -e "${enVert}${enGras}$i ${enJaune}${enGras}: ${les_patch[$i]##*/}"
	done
	# echo -e "${enJaune}${enGras}-------------------------------------------"
	echo -e "$pied_de_page"
	}
# echo "chargement ligne $LINENO"
page_suivantePATCH () {
	# journal "appel de : ${FUNCNAME} ${@}"
	if [ $la_pagePATCH -lt $nbre_page_patch ] ; then let la_pagePATCH++ ; fi 
	}
# echo "chargement ligne $LINENO"
page_precedentePATCH () {
	# journal "appel de : ${FUNCNAME} ${@}"
	if [ $la_pagePATCH -gt 1 ] ; then let la_pagePATCH-- ; fi
	}
# echo "chargement ligne $LINENO"
lancerPATCH () {
	if [[ -e "${@}/main.pil" ]] ; then 
		journal "fichier lanceur main.pil trouvé dans \n${@}"
		"${@}/main.pil" 
	else
		if [[ -e "${@}/install.sh" ]] ; then 
			journal "fichier lanceur install.sh trouvé dans \n${@}"
			"${@}/install.sh"
		else
			journal "aucun fichier lanceur trouvé dans \n${@}"
		fi 
	fi
	}
# echo "chargement ligne $LINENO"
parserChoixPATCH () {
	# journal "appel de : ${FUNCNAME} ${@}"
	case "$choixPATCH" in
		0) 
			# journal "ChoixPATCH=${ChoixPATCH}\nTODO : choisir une patch" ;
			echo "# rien à faire encore avec les 0 des PATCH ;°)"
			sleep 3 
			# pause ; 
			# mainPATCH 
			;;
		[1-9]|[0-9][0-9]) 
			journal "choixPATCH=${choixPATCH}\n${les_patch[$choixPATCH]}"
			# bash "${les_patch[$choixPATCH]}"
			# "${les_patch[$choixPATCH]}/main.pil"
			lancerPATCH "${les_patch[$choixPATCH]}"
			pause ;;

		c|C) mainCAT ;;

		s|S) page_suivantePATCH ;;
		p|P) page_precedentePATCH ;;

		a|A) _aide ; pause ;;
		q|Q) _quitter ;;
		*)  ;;
	esac
	}
# echo "chargement ligne $LINENO"
mainPATCH () {
	# journal "appel de : ${FUNCNAME} ${@}"
	on_clear_terminal
	afficherMenuPATCH $la_pagePATCH

	# #saisie du choixPATCH
	# read -s -n 1 choixPATCH 
	read -r choixPATCH

	on_clear_terminal
	parserChoixPATCH
	mainPATCH
	}

# ****************************************************************

# DEBUT DU SCRIPT

choisir_dossier_DATA "$@"
charger_categories
mainCAT

exit 0

NB1 : pensez à rendre tous les scripts exécutable
NB j'ai encore du taf : isoler les variables, faire un fichier ini, la localisation...
mais ça bug pas en utilisation simple

Hors ligne

#18 Le 15/11/2017, à 13:25

kholo

Re : [tuto bash]script lanceur de script et post install 16.04

kipilubuntu v0.013

#!/bin/bash
# ----------------------------------------------
nomlogiciel="${0##*/}"
FONCTION="lanceur de scripts ; installeurs, patchs, ppa,..."
VERSION="0.013"
# NOTES DE VERSIONS
# ----------------------------------------------
# 
# ----------------------------------------------
echo "lancement $nomlogiciel..."
sleep .5
clear

# ****************************************************************
# dir_DATA="$( realpath ${0%/*}/data_demo/ )"
# echo -e "dir_DATA\n$dir_DATA"
# ls "$dir_DATA"
# exit 0

# nautilus "$PWD" ; exit 0

# Pour éviter d'accéder en lecture à une variable n'ayant pas d'existence, 
# on peut inscrire la commande set -u en début de script.
# set -u

# pour tracer demasquer set -x
# set -x

#~**************************************************************
#~l'utilisateur est il sudoer ?
#~**************************************************************
#~echo "l'utilisateur est il sudoer ?"
#~[ -n "$( groups $USER | grep sudo )" ] && echo oui || echo non
[ -n "$( groups $USER | grep sudo )" ] || {
echo "ATTENTION
ce script est lancé par $USER qui n'est pas sudoer 
et ne pourra pas exécuter certaines fonctions"
# exit 1
}
#~**************************************************************
# msgbox () { zenity --info --text="$@" ; }

# ****************************************************************

# initialiser_variables () {
# COULEURS

fdNoir='\033[40m'
fdRouge='\033[41m'
fdVert='\033[42m'
fdJaune='\033[43m'
fdBleu='\033[44m'
fdRose='\033[45m'
fdCyan='\033[46m'
fdGris='\033[47m'
# fdDefaut='\033[49m'

enNoir='\033[30m'
enRouge='\033[31m'
enVert='\033[32m'
enJaune='\033[33m'
enBleu='\033[34m'
enRose='\033[35m'
enCyan='\033[36m'
enGris='\033[37m'
# enDefaut='\033[39m'

enGras='\033[1m'
enSouligner='\033[4m'
enClignotant='\033[5m'
enSurligner='\033[7m'
enCache='\033[8m'

enDefaut='\033[0m'

# ****************************************************************

# GENERALES
# les_cat=""
START=$(date +%s.%N)
la_pageCAT=1
la_pagePATCH=1

tete_de_page="${enJaune}${enGras}-------------------------------------------
${enRouge}${enGras}$nomlogiciel v $VERSION
${enJaune}${enGras}-------------------------------------------"
pied_de_page="
${enVert}${enGras}p ${enJaune}${enGras}: précédent\t\t\t\
${enVert}${enGras}s ${enJaune}${enGras}: suivant
${enJaune}${enGras}-------------------------------------------
${enVert}${enGras}a ${enJaune}${enGras}: aide
${enRouge}${enGras}q ${enJaune}${enGras}: quitter
${enJaune}${enGras}-------------------------------------------
${enJaune}${enGras}votre choix : ${enDefaut}"

	# }
# initialiser_variables # FIN

# ******************************************************************

splashScreen () {
echo -e "${enJaune}${enGras}
MMMMMMMMMMMMMMMMMMMMMMMNNMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
MMMMMMMMMMMMMMMMMMMMX:   .:NMMMMWXKKKKNMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
MMMMMMMMMMMMMMMMMMMM'      ;Mk'        lMMkkWMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
MMMMMMMMMMMMMMMMMMMMl      dW.        .WMx   ,0MMMMMMMMMMMMMMMMMMMMMMMMMMMMM
MMMMMMMMMMMMMMMMMMMMMKo::oKO'         KMX      ,KMMMMMMMMMMMMMMMMMMMMMMMMMMM
MMMMMMMMMMMMMMMMMMMMMNc::,.   .lOXWMMMMMx.       oMMMMMMMMMMMMMMMMMMMMMMMMMM
MMMMMMMMMMMMMMMMMMMMW'      ,KMMMMMMMMMMMWx.     oWd'..,dMMMMMMMMMMMMMMMMMMM
MMMMMMMMMMMMMMMMMMMMc      oMMMMMMMMMMMMMMMW,   ;M'      cMMMMMMMMMMMMMMMMMM
MMMMMMMMMMMMMMMMMMMN      ,MMMMMMMMMMMMMMMMMW.  ;M'      cMMMMMMMMMMMMMMMMMM
MMMMMMMMMMMMMMMMMMMK     .kMMMMMMMMMMMMMMMMMM;   lNd,..,xMMMMMMMMMMMMMMMMMMM
MMMMMMMMMMMMMMMMMMMWO0XWMMMMMMMMMMMMMMMMMMMMM.     oMMMMMMMMMMMMMMMMMMMMMMMM
MMMMMMMMMMMMMMMMMMMM0l:;'..xMMMMMMMMMMMMMMMMc      oMMMMMMMMMMMMMMMMMMMMMMMM
MMMMMMMMMMMMMMMMMMMMX.      cNMMMMMMMMMMMMMc      'WMMMMMMMMMMMMMMMMMMMMMMMM
MMMMMMMMMMMMMMMMMMMMMX.       ;xKWMMMMW0d0MWl    ,WMMMMMMMMMMMMMMMMMMMMMMMMM
MMMMMMMMMMMMMMMMMMMMMMWl          ...     ;XMX, dMMMMMMMMMMMMMMMMMMMMMMMMMMM
MMMMMMMMMMMMMMMMMMMMMMMMXc.:oddc'           lWMWMMMMMMMMMMMMMMMMMMMMMMMMMMMM
MMMMMMMMMMMMMMMMMMMMMMMMMMNo'..:OX,      .,o0MMMMMMMMMMMMWMMMMMMMMWNMMMMMMMM
MMX00000000XMMW0000000KMMM.      xW;;:cok0000XMMMMMMMMMX. :MMMMWO; 'MMMMMMMM
MMKx:    :xKMMWk;   .lOMMM.      xWkx.     .   'xMMMMMMk  .MMM0;.  'MMMMMMMM
MMMMM,  ,MMMMMMMd  dMMMMMMNl'..;OMMMMK   0MMWx.  'NMMMMMdc0MMMMMK  'MMMMMMMM
MMMMMc  cMMMMMMO .XMMMMMMMMMMMMMMMMMMW   KMMMMX   .WMMMMMMMMMMMMN  'MMMMMMMM
MMMMMc  cMMMMMd :WMMMMMMMMMMMMMMMMMMMM   KMMMMMl   kMMMMMMMMMMMMN  'MMMMMMMM
MMMMMc  cMMMW; oMMMMMMMMMMMMMMMMMMMMMM   KMMMMMk   oMMMMMMMMMMMMN  'MMMMMMMM
MMMMMc  cMMK. OMMMMMMMMMMMMMOc.oMMMMMM   KMMMMMk   dMMMKl.,MMMMMN  'MMMMMMMM
MMMMMc  cMx .XMMMMMMMMMMMMk'   lMMMMMM   KMMMMM,   NM0,   ,MMMMMN  'MMMMMMMM
MMMMMc  ;; .NMMMMMMMMMMMMMMMo  lMMMMMM   KMMMWc   kMMMMO  ,MMMMMN  'MMMMMMMM
MMMMMc  .   .XMMMMMMMMMMMMMMk  lMMMMMM   ':c:.  '0MMMMMN  ,MMMMMN  'MMMMMMMM
MMMMMc  cO    OMMMMMMMMMMMMMk  lMMMMMM   O0kxxONMMMMMMMN  ,MMMMMN  'MMMMMMMM
MMMMMc  cMX.   oMMMMMMMMMMMMk  lMMMMMM   KMMMMMMMMMMMMMN  ,MMMMMN  'MMMMMMMM
MMMMMc  cMMN,   ;WMMMMMMMMMMk  lMMMMMM   KMMMMMMMMMMMMMN  ,MMMMMN  'MMMMMMMM
MMMMMc  cMMMMo   .XMMMMMMMMMk  lMMMMMM   KMMMMMMMMMMMMMN  ,MMMMMN  'MMMMMMMM
MMMMMc  cMMMMMO.   OMMMMMMMMk  lMMMMMM   KMMMMMMMMMMMMMN  ,MMMMMN  'MMMMMMMM
MMMMM:  cMMMMMMX.   oWMMMMMMk  lMMMMMW   KMMMMMMMMMMMMMN  ,MMMMMN  'MMMMMMMM
MMMMM'  ,MMMMMMMX    .0MMMMMx  cMMMMMK   xMMMMMMMMMMMMMK  .MMMMMK  .MMMMMMMM
MMOo,    ,oOMMMO;      .ckKo.   cOWdl.    ldXMMMMMMMMNo.   :kMNd.   :dWMMMMM
MMNXXXXXXXXNMMMNXXXXXXXXXNWXXXXXXNMXXXXXXXXXWMMMMMMMMWXXXXXXXMWXXXXXXXMMMMMM
MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
$nomlogiciel v $VERSION"
sleep .8
	}
splashScreen
# ****************************************************************

# JOURNAL

initialiser_journal () {
	fichier_log="$nomlogiciel.log"
	# #[ ! -f "$fichier_log" ] && \#
	> "$fichier_log" 
	journal "*******************initialisation*******************"
	journal "chargement"
	}
journal () {
	local NOW=$(date +%s.%N)
	local DIFF=$(echo "${NOW} - ${START}" | bc)
	echo -e "[${DIFF}] ------------------\n${@}" >> "${fichier_log}"
	# echo -e "$@" >> "$fichier_log"
	}
initialiser_journal

# ****************************************************************

# catch CTRL-C
trap "echo ''; echo 'sortie avec CTR-C. on quitte' ; sleep 2 ; exit 1" 2

# ****************************************************************

# FONCTIONS

# echo "chargement ligne $LINENO"
string_to_int (){
	LANG=C
	printf %.0f ${1/,/.}
	}

_quitter () {
	journal "appel de : ${FUNCNAME} ${@}"
	# mettre ici tout ce qui sera nescessaire à la bonne fermeture
	# ...
	exit 0
	}
# echo "chargement ligne $LINENO"
pause () {
	echo -e "${enVert}${enGras}Appuyer sur une touche pour continuer..."
	read -s -n 1
	}
# echo "chargement ligne $LINENO"
on_clear_terminal () {
	echo "${enDefaut}"
	reset > /dev/null
	}

# ****************************************************************

# PARTIE CATEGORIE

# echo "chargement ligne $LINENO"
choisir_dossier_DATA () {
	journal "appel de : ${FUNCNAME} ${@}"

	# dir_DATA=./data/
	# dir_DATA=./data_test/
	# dir_DATA="$( realpath "$dir_DATA" )"
	# #dir_DATA="$( readlink -e "$dir_DATA" )"
	# #dir_DATA="$( readlink -m "$dir_DATA" )"

	# dir_DATA="$( realpath ./data_demo/ )"
	dir_DATA="$( realpath ${0%/*} )"
	dir_DATA="$( readlink -m "$dir_DATA" )"
	dir_DATA="$dir_DATA/data_demo/"
	[[ -n ${@} ]] && dir_DATA="${@}"
	
	if [[ ! -d "$dir_DATA" ]]
	then 
		journal "erreur :\ndossier DATA : $dir_DATA" ; 
		exit 1 ; 
	fi
	journal "dossier DATA : $dir_DATA"
	}
# echo "chargement ligne $LINENO"
charger_categories () {
	journal "appel de : ${FUNCNAME} ${@}"
	les_cat=$(find "$dir_DATA" -maxdepth 1 -type d | sort)
	IFS=$'\n' les_cat=( $les_cat )
	# IFS=$'\n' 
	nbre_cat=${#les_cat[@]}

	nbre_page_cat=$(( 1+$nbre_cat/9 ))
	journal "nbre cats : $nbre_cat\nnbre pages : $nbre_page_cat"
	}


# echo "chargement ligne $LINENO"
afficherMenuCAT () {
	# journal "appel de : ${FUNCNAME} ${@}"
	multiCAT=$1
	echo -e "$tete_de_page"
	echo -e "${enJaune}CATEGORIES - ${enGras}page $multiCAT/$nbre_page_cat\n"

	for (( i=$(string_to_int $(($multiCAT-1))0); i<=$(string_to_int $(($multiCAT-1))9); i++ ))
	do
		[ -n "${les_cat[$i]}" ] && [ $i -ne 0 ] && echo -e "${enVert}${enGras}$i ${enJaune}${enGras}: ${les_cat[$i]##*/}"
	done
	# echo -e "${enJaune}${enGras}-------------------------------------------"
	echo -en "$pied_de_page"
	}
# echo "chargement ligne $LINENO"
page_suivanteCAT () {
	# journal "appel de : ${FUNCNAME} ${@}"
	if [ $la_pageCAT -lt $nbre_page_cat ] ; then let la_pageCAT++ ; fi
	}
# echo "chargement ligne $LINENO"
page_precedenteCAT () {
	# journal "appel de : ${FUNCNAME} ${@}"
	if [ $la_pageCAT -gt 1 ] ; then let la_pageCAT-- ; fi
	}
# echo "chargement ligne $LINENO"
parserChoixCAT () {
	# journal "appel de : ${FUNCNAME} ${@}"
	case "$choixCAT" in
		0) 
			journal "choixCAT=${choixCAT}\nTODO : choisir une cat" ; 
			echo "# rien à faire encore avec les 0 des CAT ;°)"
			sleep 2
			# pause ; 
			# mainCAT 
			;;

		[1-9]|[0-9][0-9]) 
			journal "choixCAT=${choixCAT}\n${les_cat[$choixCAT]}"
			la_cat="${les_cat[$choixCAT]}"
			choisir_dossier_PATCH "$la_cat"
			charger_patch
			mainPATCH
			pause
			;;

		# c|C) mainCAT ;;

		s|S) page_suivanteCAT ;;
		p|P) page_precedenteCAT ;;

		a|A) _aide  ; pause ;;
		q|Q) _quitter ;;
		*)  ;;
	esac
	
	}
# echo "chargement ligne $LINENO"
mainCAT () {
	la_pagePATCH=1
	# journal "appel de : ${FUNCNAME} ${@}"
	on_clear_terminal
	afficherMenuCAT $la_pageCAT

	# #saisie du choixCAT
	# read -s -n 1 choixCAT 
	read -r choixCAT 

	on_clear_terminal
	parserChoixCAT
	mainCAT
	}

_aide () {
echo -e "${enJaune}${enGras}"
cat << FIN 
POST INSTALLATION UBUNTU - Le PC à Kiki

Suite à ce tuto initialement posté sur le forum de Ubuntu fr
https://forum.ubuntu-fr.org/viewtopic.php?id=1993089

transcription en script bash.

Principe :
Le script principal n'est qu'un luncheur qui recense les dossiers 
contenus dans un dossier data 
ET qui contiennent des lanceurs eux même en bash 

Chaque lanceur peut être lancé indépendement sans dépendance.

Utilisation :
lancer $0 (pas de droits élevés)
$0
choisir une catégorie
lancer un patch à appliquer
donner le mot de passe root pour chaque nouvelle action
si celui ci est demandé.



TODO installation des dépendances :
la totalité des pgms utilisés doivent faire parti du système ou de bash :
cd, sed, echo, function,...
FIN
	}

# ****************************************************************

# PARTIE PATCH

# echo "chargement ligne $LINENO"
choisir_dossier_PATCH () {
	# journal "appel de : ${FUNCNAME} ${@}"
	# dir_PATCH="$dir_DATA/00tests/"
	dir_PATCH="$@"
	# dir_PATCH="$dir_DATA/sudoer/"
	
	journal "dossier PATCH\n$dir_PATCH"
	}
# echo "chargement ligne $LINENO"
charger_patch () {
	# journal "appel de : ${FUNCNAME} ${@}"
	les_patch=$(find "$dir_PATCH" -maxdepth 1 -type d | sort)
	IFS=$'\n' les_patch=( $les_patch )
	nbre_patch=${#les_patch[@]}
	nbre_page_patch=$(( 1+$nbre_patch/9 ))

	journal "nbre_patch=$nbre_patch\nnbre_page_patch=$nbre_page_patch"
	# pause
	}

# echo "chargement ligne $LINENO"
page_suivantePATCH () {
	# journal "appel de : ${FUNCNAME} ${@}"
	if [ $la_pagePATCH -lt $nbre_page_patch ] ; then let la_pagePATCH++ ; fi 
	}
# echo "chargement ligne $LINENO"
page_precedentePATCH () {
	# journal "appel de : ${FUNCNAME} ${@}"
	if [ $la_pagePATCH -gt 1 ] ; then let la_pagePATCH-- ; fi
	}
# echo "chargement ligne $LINENO"
lancerPATCH () {
	if [[ -e "${@}/main.pil" ]] ; then 
		journal "fichier lanceur main.pil trouvé dans \n${@}"
		"${@}/main.pil" 
	else
		if [[ -e "${@}/install.sh" ]] ; then 
			journal "fichier lanceur install.sh trouvé dans \n${@}"
			"${@}/install.sh"
		else
			journal "aucun fichier lanceur trouvé dans \n${@}"
		fi 
	fi
	}
# echo "chargement ligne $LINENO"
parserChoixPATCH () {
	journal "appel de : ${FUNCNAME} ${@}"
	case "$choixPATCH" in
		0) 
			# journal "ChoixPATCH=${ChoixPATCH}\nTODO : choisir une patch" ;
			echo "# rien à faire encore avec les 0 des PATCH ;°)"
			sleep 3 
			# pause
			;;
		[1-9]|[0-9][0-9]) 
			# choix = 0 à 9 ou 10 à 99 ; pour 999 ajouter "|[0-9][0-9][0-9]"
			journal "choixPATCH=${choixPATCH}\n${les_patch[$choixPATCH]}"
			echo -e "${enBleu}${enGras}"
			lancerPATCH "${les_patch[$choixPATCH]}"
			# pause 
			;;

		# c|C) mainCAT ;;

		# s|S) page_suivantePATCH ;;
		# p|P) page_precedentePATCH ;;

		# a|A) _aide ; pause ;;
		# a|A) _aide ;;
		# q|Q) _quitter ;;
		# *)  ;;
	esac
	}
# echo "chargement ligne $LINENO"


mainPATCH () {
# source menu.source
laPhrase="choisir des éléments"
LeTitre="un titre ici" # defaut

IFS=$'\n'
mMenu=()

# i=0
i=-1
for f in ${les_patch[@]}
do
	[ -n $f ] && {
		((i++))
		mMenu+=($i "${f##*/}" OFF)
	}
done

# https://www.unix.com/shell-programming-and-scripting/110425-shift-array-element.html
# array=( a b c d e f g h i j k l ) ## define array
# 
# unset array[0]              ## remove element
# array=( "${array[@]}" )     ## pack array 'je pense pas que ça puisse marcher avec les quottes
# 
# printf "%s\n" "${array[@]}" ## print array

# on récupère la première ligne qui est le dossier parents des éléments
LeTitre="${mMenu[1]}"
# on supprime cette première ligne : 3 éléments
unset mMenu[0]
unset mMenu[1]
unset mMenu[2]
mMenu=( ${mMenu[@]} )

aFaire=$(whiptail --title "$LeTitre" --checklist "$laPhrase" --separate-output 15 60 4 ${mMenu[@]} 3>&1 1>&2 2>&3 ;)
# echo ""
IFS=$' \t\n'
for choixPATCH in ${aFaire[@]}
do
	# echo "on lance $choixPATCH : ${les_patch[$choixPATCH]}"
	# echo "on lance $choixPATCH"
	parserChoixPATCH $choixPATCH
done
}

# ****************************************************************

# DEBUT DU SCRIPT

choisir_dossier_DATA "$@"
charger_categories
mainCAT

exit 0

Hors ligne