deamon/gestionnaire de taches en Bash (Linux)

Sonn
Hackadémicien
Membre intéressé
Inscription: décembre 2011
Messages: 53
17 février 2012, 18h11
Bonjour,

J'avais commencé à me faire un gestionnaire de tâches qui permettais d'exécuter automatiquement des codes stockés dans des variables en bash, puis j'ai voulu le transformer en deamon mais je n'ai plus le temps de continuer le développement ^^ J'ai d'autres projets actuellement...

S'il peut servir de base pour quelqu'un, allez-y ! Mais si vous le modifiez, faites-moi part de vos modifications que je puisse également copier les améliorations
En revanche ATTENTION ! Ce script peut être dangereux car il est sûrement buggué et je ne l'ai pas re-testé, de plus il nécessite les droits root.

A lancer avec méfiance après analyse du code
Ma petite contribution au forum
Code:
#!/bin/bash

xhost +
clear

#version 0.8

#####################################
          ##CONFIGURATION##
#####################################

#variables supplémentaires utilisées :
# mdp
# afficher_message
# quitter
# mois
# jour
# heure
# minute

repertoires=\
(
	'/gestionnaire_de_taches' \
	'/gestionnaire_de_taches/script' \
	'/gestionnaire_de_taches/sauvegarde' \
	'/gestionnaire_de_taches/sauvegarde/actuel' \
	'/gestionnaire_de_taches/sauvegarde/supprimer'\
)
fichiers=\
(
	'/gestionnaire_de_taches/script/log' \
	'/gestionnaire_de_taches/script/systeme' \
	'/gestionnaire_de_taches/script/pense_bete' \
)


let "nb_essai_restant = 3"
s_mdp="test"
ner="Nombre d'essai restant :"

#
install_non_t="Erreur fatale!"
install_non_m="Le script n'est pas installé!"

root_manquant_t="Erreur fatale!"
root_manquant_m="Ce script nécessite d'etre lancé en tant que root!"

plm_t="Erreur fatale!"
plm_m="Paramètre de lancement manquant!"

pli_t="Erreur fatale!"
pli_m="Paramètre de lancement incorrect!"

entrer_mdp_t="Informations requises"
entrer_mdp_m="Entrez votre mot de passe:"

mdp_vide_t="Erreur!"
mdp_vide_m="Votre mot de passe est vide!"

mdp_incorrect_t="Erreur!"
mdp_incorrect_m="Votre mot de passe est incorrect!"

mdp_erreur_t="Erreur fatale!"
mdp_erreur_m="Vous avez fait trop d'erreurs pour le mot de passe!"

msg_bienvenue_t="Bienvenue!"
msg_bienvenue_m="Bienvenue!"

entrer_choix_t="Informations requises"
entrer_choix_m="Entrez votre choix :"

choix_vide_t="Erreur!"
choix_vide_m="Votre choix est vide!"

choix_incorrect_l="Erreur!"
choix_incorrect_m="Choix incorrect !"

fenetre_fermee_t="Erreur!"
fenetre_fermee_m="Fenetre fermée sans entrer les informations nécessaires!"

msg_quitter_t="Informations requises"
msg_quitter_m="Voulez-vous continuer ?[o/n]"

au_revoir_t="Au revoir!"
au_revoir_m="Merci d'avoir utilisé ce script :p"
#

#messages servant pour les log
lancement_t="Information"
lancement_m="Lancement du script..."

execution_fonction_terminal_t="Information"
execution_fonction_terminal_m="Execution d'une fonction de l'environnement terminal"

execution_fonction_zenity_t="Information"
execution_fonction_zenity_m="Execution d'une fonction de l'environnement zenity"

execution_installation_t="Information"
execution_installation_m="Execution de la fonction installation"


# 01 = lancer sans root
exit01_t="Exit"
exit01_m="$root_manquant_m"

# 02 = lancer sans être installé
exit02_t="Exit"
exit02_m="$install_non_m"

# 03 = fin normal de la fonction installation
exit03_t="Exit"
exit03_m="fin normal de la fonction installation"

# 04 = lancer sans parametre
exit04_t="Exit"
exit04_m="$plm_m"

# 05 = lancer avec un parametre incorrect
exit05_t="Exit"
exit05_m="$pli_m"

# 06 = fin normal de la session sans environnement fonction terminal
exit06_t="Exit"
exit06_m="fin normal de la session sans environnement fonction terminal"

# 07 = fin normal de la session sans environnement fonction zenity
exit07_t="Exit"
exit07_m="fin normal de la session sans environnement fonction zenity"

# 08 = fin normal de cron
exit08_t="Exit"
exit08_m="Fin normal de cron"

# 09 = trop d'erreurs de mdp dans l'environnement terminal
exit09_t="Exit"
exit09_m="trop d'erreurs de mdp dans l'environnement terminal"

# 10 = fin normal de la session d'environnement terminal
exit10_t="Exit"
exit10_m="fin normal de la session d'environnement terminal"

# 11 = trop d'erreurs de mdp dans l'environnement zenity
exit11_t="Exit"
exit11_m="trop d'erreurs de mdp dans l'environnement zenity"

# 12 = fin normal de la session d'environnement zenity
exit12_t="Exit"
exit12_m="fin normal de la session d'environnement zenity"

#lancement message
l_t="Information"
l_m_1="Vous avez lancé" #$0
l_m_2="avec" #$#
l_m_3="paramètres dans l'environnement "
#fin lancement message
#


#####################################
          ##PROGRAMMES##
#####################################

#!/bin/bash

#définitions des array
#

noms_fonctions_terminal=(
	'terminal_00'
	'terminal_01'
	'terminal_02'
	'terminal_03'
	'terminal_04'
	'terminal_05'
	'terminal_06'
	'terminal_07'
	'terminal_08'
	'terminal_09'
	'terminal_10'
)
descriptions_fonctions_terminal=(
	'Quitter'
	'Obtenir la liste des commandes les plus utiles'
	'Mettre à jour votre cache de paquets et vos paquets'
	'Obtenir la liste des utilisateurs de la machine courante'
	'Chiffrer une variable en sha1'
	'vide'
	'vide'
	'vide'
	'vide'
	'vide'
	'vide'
)
noms_fonctions_zenity=(
	'zenity_00'
	'zenity_01'
	'zenity_02'
	'zenity_03'
	'zenity_04'
	'zenity_05'
	'zenity_06'
	'zenity_07'
	'zenity_08'
	'zenity_09'
	'zenity_10'
)
descriptions_fonctions_zenity=(
	'Quitter'
	'vide'
	'vide'
	'vide'
	'vide'
	'vide'
	'vide'
	'vide'
	'vide'
	'vide'
	'vide'
)


#
#fin des définitions des array

# définition des fonctions terminal
#

function terminal_00
{
	echo
}
function terminal_01
{
	echo "Pour obtenir une liste des commandes les plus utiles :"
	echo "http://doc.ubuntu-fr.org/commande_shell"
}
function terminal_02
{
	apt-get update
	apt-get upgrade
}
function terminal_03
{
	n=1 # Nombre d'utilisateurs
	for nom in $(awk 'BEGIN{FS=":"}{print $1}' < "/etc/passwd" )
	do
		echo "UTILISATEUR #$n = $nom"
		let "n += 1"
	done
}
function terminal_04
{
	read -p "Entrez votre mot de passe:" -s var
	read sha1 x < <(sha1sum <<< "$var")
	echo -e "\nVotre mdp en sha1 ="
	echo $sha1
}
function terminal_05
{
	dmidecode
}
function terminal_06
{
	echo "fonction vide :p"
}
function terminal_07
{
	echo "fonction vide :p"
}
function terminal_08
{
	echo "fonction vide :p"
}
function terminal_09
{
	echo "fonction vide :p"
}
function terminal_10
{
	echo "fonction vide :p"
}
#
# fin définition des fonctions terminal

# définition des fonctions zenity
#
function zenity_00
{
	echo
}
function zenity_01
{
	zenity --info title="Vide!" --text="Vide!"
}
function zenity_02
{
	zenity --info title="Vide!" --text="Vide!"
}
function zenity_03
{
	zenity --info title="Vide!" --text="Vide!"
}
function zenity_04
{
	zenity --info title="Vide!" --text="Vide!"
}
function zenity_05
{
	zenity --info title="Vide!" --text="Vide!"
}
function zenity_06
{
	zenity --info title="Vide!" --text="Vide!"
}
function zenity_07
{
	zenity --info title="Vide!" --text="Vide!"
}
function zenity_09
{
	zenity --info title="Vide!" --text="Vide!"
}
function zenity_10
{
	zenity --info title="Vide!" --text="Vide!"
}

#
# fin définition des fonctions zenity


#####################################
          ##FONCTIONS##
#####################################

#définitions des fonctions systèmes
#

function installation
{
	if [ -d "${repertoires[0]}" ]
	then
		read -p "Le répertoire ${repertoires[0]} existe déjà, il seras effacer"
		sudo rm -r "${repertoires[0]}"
	fi

	for i in ${!repertoires[*]} ; do 
		sudo mkdir "${repertoires[i]}"
	done

	for i in ${!fichiers[*]} ; do
		sudo touch "${fichiers[i]}"
	done

	sudo mv  "${repertoires[1]}"
	sudo chown -R root:root "${repertoires[0]}"
	sudo chmod -R 000 "${repertoires[0]}"

	sudo echo -e "\n * *     * * *   root    ${repertoires[1]}/script.sh cron \n" >> /etc/crontab

	sudo rm -r `pwd`
}

function initialisation
{
	echo -e "\n`date +%Y-%m-%d\;%H:%M:%S` -- `echo $USER` -- $lancement_t -- $lancement_m" >> "${fichiers[0]}"

	menu_terminal="Menu de : ${#noms_fonctions_terminal[*]} programmes\n"
	for i in ${!noms_fonctions_terminal[*]}
	do
		menu_terminal+="$i => ${descriptions_fonctions_terminal[i]} \n"
	done
}

function log
{
	echo `date +%Y-%m-%d\;%H:%M:%S` -- `logname` -- "$1" -- "$2" >> "${fichiers[0]}"
}

#définitions des fonctions de l'environnement terminal
#

function terminal_verification_mdp
{
	while true
	do
		read -p "$entrer_mdp_m" -s mdp
		echo

		#si le mdp entré est vide
		if [ -z "$mdp" ]
		then
			log "$mdp_vide_t" "$mdp_vide_m"
			echo "$mdp_vide_m"

		#si le mdp entré est incorrect
		elif [ -n "$mdp" ]&&[ "$mdp" != "$s_mdp" ]
		then
			log "$mdp_incorrect_t" "$mdp_incorrect_m"
			echo "$mdp_incorrect_m"

		#si le mdp est correct
		elif [ -n "$mdp" ]&&[ "$mdp" == "$s_mdp" ]
		then
			break
		fi

		let "nb_essai_restant = nb_essai_restant-1"
		echo "$ner $nb_essai_restant"

		#si le nombre d'essai restant est inférieur ou égal à 0
		if [ "$nb_essai_restant" -le 0 ]
		then
			clear
			echo "$mdp_erreur_m"
			log "$exit09_t" "$exit09_m"
			exit 9
		fi

		echo
	done
}

function terminal_choisir_programme
{
	while true
	do
		echo -e "$menu_terminal"; afficher_message=false
		read -p "$entrer_choix_m" choix

		if [ -z "$choix" ]
		then
			log "$choix_vide_t" "$choix_vide_m"
			echo -e "$choix_vide_m"
		else
			case "$choix" in
				"0") eval ${noms_fonctions_terminal[0]} ;afficher_message=true; ;;
				"1") eval ${noms_fonctions_terminal[1]} ;afficher_message=true; ;;
				"2") eval ${noms_fonctions_terminal[2]} ;afficher_message=true; ;;
				"3") eval ${noms_fonctions_terminal[3]} ;afficher_message=true; ;;
				"4") eval ${noms_fonctions_terminal[4]} ;afficher_message=true; ;;
				"5") eval ${noms_fonctions_terminal[5]} ;afficher_message=true; ;;
				"6") eval ${noms_fonctions_terminal[6]} ;afficher_message=true; ;;
				"7") eval ${noms_fonctions_terminal[7]} ;afficher_message=true; ;;
				"8") eval ${noms_fonctions_terminal[8]} ;afficher_message=true; ;;
				"9") eval ${noms_fonctions_terminal[9]} ;afficher_message=true; ;;
				"10")eval ${noms_fonctions_terminal[10]};afficher_message=true; ;;
				*)   log "$choix_incorrect_t" "$choix_incorrect_t" ; echo -e "$choix_incorrect_m"; ;;
			esac
		fi
		if [ "$afficher_message" == true ]
		then
			terminal_message_quitter
		fi
	done
}

function terminal_message_quitter
{
	while true
	do
		read -p "$msg_quitter_m" quitter
		if [ -z $quitter ]
		then
			echo 
		elif [ $quitter == "o" ]||[ $quitter == "O" ]||[ $quitter == "y" ]||[ $quitter == "Y" ]
		then
			break
		elif [ $quitter == "n" ]||[ $quitter == "N" ]
		then
			clear
			echo "$au_revoir_m"
			log "$exit10_t" "$exit10_m"
			exit 10
		fi
	done
}

#
#fin définitions des fonctions de l'environnement terminal


#définitions des fonctions de l'environnement zenity
#
function zenity_verification_mdp
{
	while true
	do
		if mdp=`zenity --entry --title="$entrer_mdp_t" --text="$entrer_mdp_m \n $ner $nb_essai_restant" --hide-text`
		then
			#si le mdp entré est vide
			if [ -z "$mdp" ]
			then
				zenity --error --title="$mdp_vide_t" --text="$mdp_vide_m"

			#si le mdp entré est incorrect
			elif [ -n "$mdp" ]&&[ "$mdp" != "$s_mdp" ]
			then
				zenity --error --title="$mdp_incorrect_t" --text="$mdp_incorrect_m"

			#si le mdp est correct
			elif [ -n "$mdp" ]&&[ "$mdp" == "$s_mdp" ]
			then
				break
			fi
		else
			zenity --error --title="$fenetre_fermee_t" --text="$fenetre_fermee_m"
		fi

		let "nb_essai_restant = nb_essai_restant-1"

		#si le nombre d'essai restant est inférieur ou égal à 0
		if [ "$nb_essai_restant" -le 0 ]
		then
			zenity --error --title="$mdp_erreur_t" --text="$mdp_erreur_m"
			log "$exit11_t" "$exit11_m"
			exit 11
		fi
	done
}

function zenity_choisir_programme
{
	while true
	do
		choix=`zenity --list --title="$entrer_choix_t" --text="$entrer_choix_m" --column="N°" --column="Programmes" \
		0 "${descriptions_fonctions_zenity[0]}" 1 "${descriptions_fonctions_zenity[1]}" 2 "${descriptions_fonctions_zenity[2]}" \
		3 "${descriptions_fonctions_zenity[3]}" 4 "${descriptions_fonctions_zenity[4]}" 5 "${descriptions_fonctions_zenity[5]}" \
		6 "${descriptions_fonctions_zenity[6]}" 7 "${descriptions_fonctions_zenity[7]}" 8 "${descriptions_fonctions_zenity[8]}" \
		9 "${descriptions_fonctions_zenity[9]}" 10 "${descriptions_fonctions_zenity[10]}" `
		afficher_message=false

		if [ -z "$choix" ]
		then
			echo -e "$choix_vide_m"
		else
			case "$choix" in
				"0") eval ${noms_fonctions_zenity[0]} ;afficher_message=true; ;;
				"1") eval ${noms_fonctions_zenity[1]} ;afficher_message=true; ;;
				"2") eval ${noms_fonctions_zenity[2]} ;afficher_message=true; ;;
				"3") eval ${noms_fonctions_zenity[3]} ;afficher_message=true; ;;
				"4") eval ${noms_fonctions_zenity[4]} ;afficher_message=true; ;;
				"5") eval ${noms_fonctions_zenity[5]} ;afficher_message=true; ;;
				"6") eval ${noms_fonctions_zenity[6]} ;afficher_message=true; ;;
				"7") eval ${noms_fonctions_zenity[7]} ;afficher_message=true; ;;
				"8") eval ${noms_fonctions_zenity[8]} ;afficher_message=true; ;;
				"9") eval ${noms_fonctions_zenity[9]} ;afficher_message=true; ;;
				"10")eval ${noms_fonctions_zenity[10]};afficher_message=true; ;;
				*)   echo -e "$choix_incorrect_m"; ;;
			esac
		fi

		if [ "$afficher_message" == true ]
		then
			zenity_message_quitter
		fi
	done
}

function zenity_message_quitter
{
	while true
	do
		zenity --question --title "$msg_quitter_t" --text "$msg_quitter_m"
		if [ $? == 0 ]
		then
			break
		else
			zenity --info --title="$au_revoir_t" --text="$au_revoir_m"
			log "$exit12_t" "$exit12_m"
			exit 12
		fi
	done
}

#
#fin définitions des fonctions de l'environnement zenity

#####################################
              ##CRON##
#####################################

function cron
{
	let "mois   = `date +%m`" ; let "jour   = `date +%d`"
	let "heure  = `date +%H`" ; let "minute = `date +%M`"

	if [ $mois == $mois ] && [ $jour == $jour ] && [ $heure == $heure ] && [ $minute == 0 ] #donc toutes les heures ;)
	then
		./rsync.sh
	fi
}

#####################################
              ##SCRIPT##
#####################################

initialisation

case "$1" in
start)
# Placez ici les commandes à exécuter uniquement au lancement du script
#zenity --info --text="ordinateur lancer :p"
;;

stop)
# Placez ici les commandes à exécuter uniquement à l'arrêt du script
#zenity --info --text="ordinateur en train de s'eteindre :p"
;;

*)
# On indique ici comment utiliser le script, c'est dans le cas où le script est appelé sans argument ou avec un argument invalide
echo 'Usage: /etc/init.d/helloworld {start|stop}'
exit 1
;;
esac

exit 0


#possibilité n°2 parametre = terminal
if [ "$1" == "terminal" ]
then
	for i in ${!noms_fonctions_terminal[*]} #on recherche une fonction terminal qui aurais le meme nom que le parametre
	do
		if [ "$1" == "${noms_fonctions_terminal[i]}" ]
		then
			log "$execution_fonction_terminal_t" "$execution_fonction_terminal_m"
			eval "${noms_fonctions_terminal[i]}"
			log "$exit06_t" "$exit06_m"
			exit 6
		fi
	done

	log "$l_t" "$l_m_1 $0 $l_m_2 $# $l_m_3 $1"
	echo -e "$l_m_1 $0 $l_m_2 $# $l_m_3 $1\n"
	terminal_verification_mdp
	echo "$msg_bienvenue_m"
	terminal_choisir_programme

#possibilité n°3 parametre = zenity
elif [ "$1" == "zenity" ]
then
	for i in ${!noms_fonctions_zenity[*]} #on recherche une fonction zenity qui aurais le meme nom que le parametre
	do
		if [ "$1" == "${noms_fonctions_zenity[i]}" ]
		then
			log "$execution_fonction_zenity_t" "$execution_fonction_zenity_m"
			eval "${noms_fonctions_zenity[i]}"
			log "$exit07_t" "$exit07_m"
			exit 7
		fi
	done

	log "$l_t" "$l_m_1 $0 $l_m_2 $# $l_m_3 $1"
	zenity --info  --title="$l_t" --text="$l_m_1 $0 $l_m_2 $# $l_m_3 $1"
	zenity_verification_mdp
	zenity --info --title="$msg_bienvenue_t" --text="$msg_bienvenue_m"
	zenity_choisir_programme

elif [ "$1" == "cron" ]
then
	cron
	log "$exit08_t" "$exit08_m"
	exit 8

elif [ "$1" == "boot" ]
then
	boot
	log "$exit09_t" "$exit09_m"
	exit 9
fi

#si on n'as pas déjà quitter, c'est que la fonction n'existe pas, donc on affiche une erreur
clear
echo "$pli_m"
zenity --error --title="$pli_t" --text="$pli_m"
log "$exit05_t" "$exit05_m"
exit 5
"Tout le monde savait que c'était impossible. Est arrivé un qui ne le savait pas et qui l'a fait !" Marcel Pagnol ////// "Certains voient les choses telles qu’elles sont et se disent pourquoi donc ? D’autres rêvent de choses qui n’ont jamais existé et se disent pourquoi pas !" George Bernard Shaw
Tags: deamongestionnaire, tâches
Précédent template Suivante
Annonce

deamon/gestionnaire de taches en Bash (Linux)

deamon/gestionnaire de taches en Bash (Linux)
