Ce site est optimisé pour être consulté depuis un navigateur moderne dans lequel JavaScript est activé.

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

kholo

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.

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

kholo

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 😉

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

bigoud92

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:

Rufus T. Firefly

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

metalux

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.

bigoud92

metalux a écritEn 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 🙂 😉

kholo

ici sur commentcamarche

kholo

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

kholo

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

erresse

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 !
🙂

kholo

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

kholo

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

[supprimé]

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 ? 🙂

kholo

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: !!!

[supprimé]

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 😉

kholo

:cool:

kholo

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

kholo

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

Crap0

Bonjour et merci (ça a l'air assez "super" et intéréssant)
Je ne vois pas trop ce que je dois faire avec ce post juste avant .... donnant le script de kipilubuntu ...
dois je le mettre dans fichier "install.sh" et situé dans un dossier home/user/bin/lanceur/kipilubuntu
puis le rendre executable ... pour m'en servire depuis le lanceur donné dans les premier post de ce fil ?
(autrement dit : faire la même démarche que pour le "PIU16.04-v0.11")

Par ce que si c'est ça : le terminal, une fois que je lance le install.sh de kipilubuntu, ne s'ouvre qu'une seconde et se referme d'aussi tot.
(je suis sous lubuntu 16.04 et j'ai changé xterm par lxterminal à certain niveau des scripts)

Voici une page que j'ai trouvé, se référant, je pense à ces post, ici... :
https://raw.githubusercontent.com/simbd/Doc/master/postinstallubuntu_listelogiciel.txt
je ne sais plus ou je l'ai déniché.
quelqu'un, sur ce second point pourrait éclairé ma lanterne ?
Qu'est ce donc cette liste : le listing des logiciel installable par cette méthode : le lanceur de lanceur de script ?

Merci d'avance !!

kholo

salut,
si tu veux regarder tout monté et utilisable, télécharge le tout sur mon site ;
tu y trouveras le montage de mes patchs (tout ok pour 16.04)

mkdir $HOME/piu
cd $HOME/piu
wget http://www.kholo-informatique.fr/download/version.txt
leFICHIER="$(< version.txt)"
wget http://www.kholo-informatique.fr/download/${leFICHIER}.zip
[ -f "${leFICHIER}.zip" ] && unzip "${leFICHIER}.zip"
[ -d "${leFICHIER}" ] && cd ${leFICHIER}/bin

fais un seul copier / coller
ça créera le dossier piu dans ton home et mettra tout dedans
ensuite comme cela t'emmène dans le bon dossier,
pour le lancer, tu fais un

./PIU.sh

ou tu zieutes dedans pour voir comment cela fonctionne !

gedit PIU.sh

Page suivante »