[script] pacgum, être avertit de ces mise à jours.

[00001000]

Aller hop et un autres script bash !

Voici pacgum un script servant à avertir des mise à jour. Ok je sait ça existe déjà, il y a zenman.
Mais quand j'ai commencer à éditer mon script je le savais pas et de plus le mien ne fonctionne pas pareil, c'est donc une alternative à zenman ou au conky avec le traditionnelle "pacman -Qu | wc -l".

Pour notifier les mises à jour pacgum utilise zenity et notify-send et pour détecter l'arriver de nouvelles mises à jour il écoute les utilisation de pacman ou yaourt avec inotifywait.
Quand il y a des mise à jour il propose de les installer avec la commande de votre choix préalablement configurer dans la partie configuration du script, quand il n'y a pas de mises a jour il vous propose de mêtre à jour la base de donnée de pacman de le même manière.
J'ai essayer de le faire aisément configurable.
Vous pouvez lui ajouter de images pour les notifications, je propose celle-ci de bases :
Images pacgum

Affin d'être averti régulièrement des nouvelles mises à jour, il faut avoir une tache cron qui exécute régulièrement la mise à jour de la base de donnée de pacman, si vous n'en avez pas le script peut vous proposé d'en crée une dans /etc/cron.daily.

Pour le reste je vous laisse voir le script lui même ici :
pacgum pastbin.archlinux.fr

[Nic0]

Salut,

Je me permet de mettre le script à la suite dans le topic pour la pérennité de celui-ci. Car je crois savoir que le pastebin est de temps en temps « purgé » pour cause de spam conséquent. Donc même si tu coches « garder toujours » il n'est pas dit qu'il soit toujours garder.
Merci pour le script (bien que je ne pense pas m'en servir :þ)

Code : Tout sélectionner

#!/bin/bash

#pacgum


#Version   : 1
#Achevé le :
#Auteur    : 00001000
#Email     : 00001000.huit@gmail.com
#Info en plus :
# * Crée sans surconsommation de bonbon par un mec apprécié de son dentiste.



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



#Définition des couleurs.
_COULERR="\033[1;31m"  #Rouge clair
_NC="\033[0m"          #Pas de couleur

#Définition des erreurs.
_NODISPLAY=140 #La variable d'environnement DISPLAY est vide.
_NOEXEC=141    #Un exécutable manque ou n'est pas exécutable.
_BADCMD=142    #La commande servant au lancement de l'émulateur de terminal revoie un erreur.

#Commande surveillé par inotifywait affin de mètre à jour l'exécution de pacgum ; voir plus bas, le chemin de yaourt est obtenus grâce à which car cela évite une erreur en l'absence de yaourt.
_UPDATRUN=( /usr/bin/pacman $(which yaourt 2> /dev/null) )

#Commande de mise à jour, utiliser un chemin complet pour accéder à la commande.
_UPDATECMD="/usr/bin/pacman" #Peut bien évidement être remplacé par yaourt
_UPGRADE_OPT="-Su" #Option pour l'installation des mise à jour.
_UPDATE_OPT="-Syuw --noconfirm" #Options pour la mise à niveau manuel de la base de donnée de yaourt.

#Vous pouvez entrer ici une commande affin de jouer un son l'ors de l'annone de nouvelles mise à jour.
#_SOUNDCMD="/usr/bin/cvlc --play-and-exit /usr/share/sounds/freedesktop/stereo/complete.oga"

#Emulateur de terminal dans le quel s'exécute les commandes de mise à jour. Vous ne devez pas utiliser un chemin complet pour accéder à cette commande.
_TERMCMD="xterm -e"

#Un fichier pouvant contenir les éventuels erreurs de ce script, je ne suis moi même pas convaincu de son utilité. Mais bon j'ai commencé le script avec donc il est encore la.
_LOGFILE="/home/$LOGNAME/.$(basename $0)-errors"

#Temps en milisecond durant le quel un notification reste affiché.
_NOTIFTIME=10000

#Ce script peut contenir des images, placez les dans le dossier voulût et indiquez le ici. Pour les détailles c'est juste en dessous.
_NOTIFICON="/home/$LOGNAME/.pacgum"

#Si vous avez crée un dossier d'images configurez les de la manières suivante
if [ -d $_NOTIFICON ]
then
    #Compléter les variables ci-dessous avec le nom de images choisis placé dans $_NOTIFICON.
    _ICON_INFO=pacgum-notif.png             #L'image qui sera utilisé pour les notifications.
    _ICON_UPDATE=pacgum-update.png          #L'image qui sera utilisé pour l'icône de notification lorsque des mises à jours seront prêtes.
    _ICON_NOUPDATE=pacgum-noupdate.png      #L'image qui sera utilisé pour l'icône de notification lorsqu'il n'y aura pas de mise à jour.
    _ICON_EXECUPDATE=pacgum-execupdate.png  #L'image qui sera utilisé pour l'icône de notification lorsqu'une mise à jour sera en cour.

    #Si les fichiers d'images existe ils sont intégrés au script.
    [ -f $_NOTIFICON/$_ICON_INFO ] && _IMGINFO="-i $_NOTIFICON/$_ICON_INFO"
    [ -f $_NOTIFICON/$_ICON_UPDATE ] && _IMGUPDATE="--window-icon=$_NOTIFICON/$_ICON_UPDATE"
    [ -f $_NOTIFICON/$_ICON_NOUPDATE ] && _IMGNOUPDATE="--window-icon=$_NOTIFICON/$_ICON_NOUPDATE"
    [ -f $_NOTIFICON/$_ICON_EXECUPDATE ] && _IMGEXECUPDATE="--window-icon=$_NOTIFICON/$_ICON_EXECUPDATE"
fi



###############################################################################
#                                                                             #
#                                  FUNCTION                                   #
#                                                                             #
###############################################################################



#Cette function averti lors d'une erreur et peut prendre comme deuxième argument un "code d'erreur affin que le script stoppe sont exécution et revoie un code d'erreur,si aucun code d'erreur n'est spécifié le scripte ne sera pas stoppé.
logerr ()
{
    echo -e "($(basename $0):$$): Erreur: $1" >> $_LOGFILE #Log l'erreur avec le message envoyé comme premier argument.
    zenity --error --title="$(basename $0) Erreur :" --text="$1" #Notifie l'erreur avec le message envoyé comme premier argument.
    if [ ! -z "$2" ] #Et si un code d'erreur est spécifié en deuxième argument quitte le scripte en revoyant ce code d'erreur.
    then
    packill #Function servant à stopper tous les sous processus et autres instance de ce script.
    exit $2
    fi
}

#Vérifie si un exécutable est présent et exécutable, si ce n'est pas le cas on l'annone et le script s'arrête.
verifexecut()
{
    for i in $@
    do
        if [ ! -x $1 ]
        then
            case $1 in

                /usr/bin/notifywait )
                logerr "Pour pouvoir utiliser ce script vous devez installer le paquet inotify-tools." "exit $_NOEXEC"
                ;;

                /usr/bin/yaourt )
                logerr "Yaourt n'est pas installé, pour remédier à ce problème modifier la variable\n_UPDATECMD dans le parte configuration de ce script ou installer le paquet yaourt." "exit $_NOEXEC"
                ;;

                /usr/bin/notify-send )
                logerr "Pour pouvoir utiliser ce script vous devez installer le paquet libnotify." "exit $_NOEXEC"
                ;;

                #Pour ceux dont le nom de l'executable est le même nom que le paquet qui permet de les installer.
                * )
                logerr "Pour pouvoir utiliser ce script vous devez installer le paquet ${1##*/}." "exit $_NOEXEC"
                ;;
            esac
        fi
    done
}    

#Cette function est appelé pour exécuter les commandes de mise à jour.
execcmd(){
    #Lance l'emulateur de terminal avec quelques commandes servant à exécuter les opérations de mise à jour, le read permet d'avoir le temps lire le résultat de celle-ci.
    $_TERMCMD "echo \"==> Entrez votre mots de passe pour $_UPDATECMD $1 :\" ; sudo $_UPDATECMD $1 ; read -p \"==> Appuyez sur entrée pour continuer ...\"" || logerr "Erreur au lancement de la commande \"execcmd\".\nVeillez vérifier celle-ci dans la parie configuration de ce script." "exit $_BADCMD" &
    touch /tmp/pacgum.temoin #Ce ficher témoin sert à briser la grande boucle plus bas, utilisé au cas ou la commande de mise à jour ne modifie pas le nombre de mises à jour disponibles.
    #Tant que l'opération de mise à jour n'est pas terminé on le signale.
    while true
    do
        zenity --notification $_IMGEXECUPDATE --title="$(basename $0)" --text="$2"
        zenity --info --title="$(basename $0)" --text="$2"
    done &
    #Au cas ou la commande de mise à jour ci dessus ne s'exécute pas on tue la commande inotifywait qui écoute la fermeture d'un accès à une des commande de mises à la fin de la grande boucle ci-dessous.
    kill $(ps -x -o"%p %c" | grep "$(pgrep -P $(pidof -x $(basename $0) | sed "s/ /,/g"))" | grep inotifywait | awk '{print $1}')
}

#Permet de tuer tous les processus fils de ce script et les autres instance de celui-ci.
packill()
{
    kill $(pgrep -P $(pidof -x $(basename $0) | sed "s/ /,/g" )) $(pidof -x $(basename $0) | sed s/$$//g ) 2> /dev/null
}



###############################################################################
#                                                                             #
#                                 EXECUTION                                   #
#                                                                             #
###############################################################################



case $1 in 

#Lance l'exécution de pacgum.
-r | --run )
    #Vérifie s'il ya un affichage disponible, sinon quitte.
    if [ -z $DISPLAY ]
    then
        echo -e "$_COULERR$(basename $0): Erreur: Impossible d'obtenir un affichage.$_NC"
        exit $_NODISPLAY
    fi
    #Si un instance de pacgum est déjà en cour d'exécution elle sera tuer.
    [ -z "$(ps -jx | grep pacgum | awk '{print $2}' | uniq | egrep [^$$] )" ] || packill
    #Vérifie qu'il est possible d'exécuter les commandes nécessaire au fonctionnement du script.
    verifexecut $_UPDATECMD /usr/bin/notifywait /usr/bin/zenity /usr/bin/notify-send /usr/bin/sudo
    #Initialisation de $_update_cmpt affin d'être sur qu'il ne sera pas égal au nombres de mise à jour et que la condition if plus bas soit vrais..
    _update_cmpt=-1
    #Commencement de la "grande boucle" sans fin qui contient la majeur partie des instructions du script..
    while true
    do
        #Si le script vient d'être lancé ou qu'il n'y a de nouvelles mise à jour ou la function execcmd à crée son fichier témoin.
        if [ $_update_cmpt != $($_UPDATECMD -Qu 2> /dev/null | wc -l) -o -f "/tmp/pacgum.temoin" ]
        then
            [ -f /tmp/pacgum.temoin ] && rm /tmp/pacgum.temoin > /dev/null #Suprétion du fichier témoin affin qu'il ne soit pas revalidé.
            #On tu tous les sous processus qui ont déjà pus être lancé, cela comprend le sous shell ainsi que la commande zenity plus bas dont il ne doit y avoir qu'une seul instance.
            #De plus s'il existe déjà un instance de pacgum en cour elle sera tuer.
            packill
            #On compte le nombre de mise à jour à effectuer.
            _update_cmpt=$($_UPDATECMD -Qu 2> /dev/null | wc -l)
            #Sert au comparatif ci-dessous affin de compter le nombre de paquets ignorés, on stocke ce résultat dans une variable car nous ne devons pas exécuter pacman ou yaourt dans le sous shell ci-dessous. Cela validerais la commande inotifywait tous en bas de cette boucle ce qui la réexecuterais depuis le début.
            _update_list=$($_UPDATECMD -Qu 2> /dev/null | cut -d / -f 2 | cut -d " " -f 1) #$_UPDATECMD peut être pacman ou yaourt qui ne produisent pas la même sortie d'où le cut du milieu.
            #Exécute dans un sous shell lancé en tache de fond les commandes ci-dessous, le but est de les faire tournés en parallèle avec le inotifywait plus bas ce qui permet qu'en cas d'actualisation du nombre de mise à jour que cette boule puisse se ré exécute affin de recrée un sous shell à jour.
            (
                #On initialise la variable qui sert à compter le nombre de paquet ignoré, voir plus bas.
                _paket_ignorer=0
                #On compte le nombre de paquet ignoré pour les mises à jour en ce basant sur le fichier de configuration de pacman.
                for _i in $(egrep "^IgnorePkg" /etc/pacman.conf | cut -d = -f 2)
                do
                    #Que l'on compare à la liste de paquets obtenu plus haut.
                    for _j in ${_update_list[@]}
                    do
                        #S'il y a correspondance on compte un paquet ignoré de plus..
                        [ $_i = $_j ] && ((_paket_ignorer++))
                    done
                done
                #Pareille que ci dessus mais pour les groupes ignoré.
                _groupe_ignorer=0
                #On compte le nombre de groupe ignoré pour les mises à jour en ce basant sur le fichier de configuration de pacman.
                for _i in $(egrep "^IgnoreGroup" /etc/pacman.conf | cut -d = -f 2)
                do
                    #Que l'on compare à la liste de paquets obtenu plus haut.
                    for _j in ${_update_list[@]}
                    do
                        #S'il y a correspondance on compte un groupe ignoré de plus..
                        [ $_i = $_j ] && ((_groupe_ignorer++))
                    done
                done
                #Si le nombre de paquet à mètre à jour moins le nombre de paquet ignoré est supérieur à zéro c'est qu'il y a des mises à jour.
                if [ $(($_update_cmpt - $_paket_ignorer)) -gt 0 ]
                then
                    #Si il y à des paquets ignorés on fait en sorte que le nombre de paquet ignoré soit indiqué.
                    if [ $_paket_ignorer -gt 0 ]
                    then
                        _disp_pki="<br>dont <b>$_paket_ignorer</b> paquet ignoré"
                        _disp_pki_notif=" dont $_paket_ignorer ignoré" #Le texte des notification zenity ne suporte pas les saut de lignes.
                        else
                        unset _disp_pki #Si lors d'une relecture de la boucle la liste de paquet ignorer passe à 0 on n'affiche plus rien.
                        unset _disp_pki_notif
                    fi
                    #Idem pour les groupes.
                    if [ $_groupe_ignorer -gt 0 ]
                    then
                        _disp_grpi="<br>et <b>$_groupe_ignorer<\b> groupe ignoré."
                        _disp_grpi_notif=" et $_groupe_ignorer ignoré."
                    else
                        unset _disp_grpi
                        unset _disp_grpi_notif
                    fi
                    #Si une commande pour jouer un son à été spécifié à la variable _SOUNDCMD un sont sera jouer pour prévenir l'ariver de nouvelles mises à jour.
                    $_SOUNDCMD &> /dev/null || logerr "La commande permettant de jouer un sont lors des mises à jour :/n$_SOUNDCMD/ncompotre un problème, vérifiez la et éditez la dans la partie configuration du script." &
                    #Notifie le fait qu'il y a des mises à jour ainsi que leur nombre.
                    notify-send -u normal -t $_NOTIFTIME $_IMGINFO "$(basename $0)" "Il y a <b>$_update_cmpt</b> mises à jour disponible $_disp_pki$_disp_grpi."
                    #Ce répète tant qu'il n'a pas été décidé de faire les mises à jour.
                    _k=1
                    while [ $_k -eq 1 ]
                    do
                        zenity --notification $_IMGUPDATE --title="$(basename $0)" --text="$_update_cmpt mises à jour$_disp_pki_notif$_disp_grpi_notif."
                        #Propose d'installer les mises à jour.
                        zenity --question --title="$(basename $0)" --text="Vous avez <b>$_update_cmpt</b> mises à jour ${_disp_pki/#<br>/\n }.\nVoulez vous les installer ?"
                        _k=$? #Permet de quitter le boucle si la raiponce à la question ci dessus est est oui.
                    done
                #Exécute la commande de mise à jour avec les option de mise à jour des paquets.
                    execcmd "$_UPGRADE_OPT" "Mise à jour du système, patientez ..."
                else
                    #Notifie qu'il n'y à pas de mises à jour.
                    notify-send -u normal -t $_NOTIFTIME $_IMGINFO "$(basename $0)" "Aucune nouvelle mise à jour."
                    _k=1
                    #Ce répète tant qu'il n'a pas été décidé de mettre à jour la base de donnée de pacman.
                    while [ $_k -eq 1 ]
                    do
                        zenity --notification $_IMGNOUPDATE --title="$(basename $0)" --text="Pas de mise à jour."
                        #Propose de mètre à jour la base de donnée de pacman.
                        zenity --question --title="$(basename $0)" --text="Vous n'avez pas de nouvelles mise à jour.\nVoulez vous mètre à jour la base de donnée de pacman ?"
                        _k=$? #Permet de quitter la boucle si la raiponce à la question ci dessus est oui.
                    done
                    #Exécute le commande de mise à jour avec les options pour mètre à jour la base de donnée de pacman.
                    execcmd "$_UPDATE_OPT" "Mise à jour de la base de donnée de pacman, patientez ..."
 
                fi
            ) & #Ce sous shell est lance en tache de fond et tourne en même temps que la commande inotifywait ci-dessous.
        fi
        #Si yaourt ou pacman sont utilisé, on attend la fin de leur exécution puis on redémarre le boucle, s'il le nombre de mise à jour à changé le sous shell plus haut est tué et un nouveau est crée avec des informations à jour.
        inotifywait -e close ${_UPDATRUN[@]}
        #Lors d'une exécution de la function execcmd la commande inotifywit ci dessus est tuer mai pour continuer le script on va attendre la fin de l'exécution du terminal servant à exécuter les commande de mises à jours.
        while [ ! -z $(ps -x -o"%p %c" | grep "$(pgrep -P $(pidof -x pacgum | sed "s/ /,/g"))" | grep ${_TERMCMD%%-*} | awk '{print $1}') ] #Contiens le pid de la commande _TERMCMD lancé par le script.
        do
            inotifywait -e close $(which ${_TERMCMD%%-*})
        done
    
    done
;;

#Permet de d'arrêter pacgum.
-k | --kill )
    #Suprime le fichier témoin crée par la function execcmd s'il existe.
    [ -f /tmp/pacgum.temoin ] && rm /tmp/pacgum.temoin > /dev/null
    #On cherche le pid de tous les processus portant le nom du script et de leur processus enfant.
    if [ -z "$(pgrep -P $(pidof -x $(basename $0) | sed "s/ /,/g" )) $(pidof -x $(basename $0) | sed s/$$//g )" ]
    then
        notify-send -u normal -t $_NOTIFTIME $_IMGINFO "$(basename $0)" "Aucune instance de $(basename $0) n'est en cour."
    else
        packill
        notify-send -u normal -t $_NOTIFTIME $_IMGINFO "$(basename $0)" "Instance de $(basename $0) arrêté."
    fi
;;

#Au besoin lancer pacgum avec cette option crée un tache journalière pour cron affin de mètre à jour la base de donnée de pacman.
-c | -create-cron )
    #Si le fichier existe déjà demande confirmation avant de le remplacer.
    if [ -f /etc/cron.daily/pac-update ]
    then
        echo -e " ==> Il existe déjà un fichier pac-update dans /etc/cron.daily/\nVoulez vous le remplacer ?"
        select _i in oui non
        do
            [ "$_i" = "oui" ] || [ "$_i" = "non" ] && break
            echo "Vous devez entrer 1 pour oui est 2 pour non."
        done
    fi

    if [ "$REPLY" != "2" ]
    then
        #Propose un peut de configuration pour le script, cette partie est à améliorer mais plus tard car au moment ou j écrit ces lignes ... J'en ai mare !
        echo -e " ==> Création d'un fichier pac-update dans /etc/cron.daily/.\n"
        echo -e "\n * Voulez vous que les erreurs soit loger dans un fichier ?\nSi oui entrez le chemin complet de ce fichier, si non ne rien mètre."
        read -p "Saisissez le chemin de votre fichier de log, par défaut aucun fichier de log : " _logfile
        echo -e "\n * Choisissez la commande qui doit être effectué affin de mètre la base de donnée de pacman à jour."
        read -p "Saisissez votre commande, le choix par défaut est /usr/bin/pacman -Syuw --noprogressbar --noconfirm : " _updatecmd

        echo "#!/bin/sh

#Cette tache à été généré par le script $(basename $0).

#Priorité du processus pour utilisation du processeur, 20 la plus basse et -20 le plus haute.
_NICE=19

#Classe ionice du processus, 0 pour aucune, 1 pour \"real time\", 2 pour \"best-effort\", 3 pour \"idle\".
_IONICE_CLASS=2

#Priorité du processus pour les entées\sorties (i\o), pour les classe ionice 1 et 2. 0 pour le priorité la plus haute et 7 pour la priorité la plus basse.
_IONICE_PRIORITY=7

#Commande de mise à jour de la base de donnée pacman.
_PACUPDATE=${_updatecmd:-\"/usr/bin/pacman -Syuw --noprogressbar --noconfirm\"}

#Configuration du log :
_LOGFILE=$_logfile
_LIGNELOG=50 #Fixe le nombre de lignes maximum que peut atteindre le fichier de log.

#Nettoie le fichier de log affin qu'il ne puisse pas dépasser le nombre de ligne fixer pas le variable _LIGNELOG. 
cleanlog() {
    #Calcule le nombre :de ligne que contiens le fichier de log.
    _nb_ligne=\$(wc -l \$_LOGFILE | cut -d \" \" -f 1)
    if [ \$_LIGNELOG -lt \$_nb_ligne ]
    then
        #Supprime les premières lignes du fichier.
        sed \"1,i\$((_nb_ligne - _LIGNELOG))d\" -i \"\$_FICHLOG\"
    fi
}


#On vérifie si le commande de mise à jour est exécutable.
if [ -x \${_PACUPDATE%%-*} ]
then

    #Donne la priorité pour utilisation du processeur 
    [ -x /usr/bin/nice ] && _PACUPDATE=\"/usr/bin/nice -n \${_NICE:-19} \$_PACUPDATE\"
    #Donne la priorité pour les entrée\sortie
    [ -x /usr/bin/ionice ] && _PACUPDATE=\"/usr/bin/ionice -c \${IONICE_CLASS:-2} -n \${IONICE_PRIORITY:-7} \$_PACUPDATE\"
    #Mise à jour de la base de donnée de pacman :
    \$_PACUPDATE 2> \$_LOGFILE ; cleanlog
fi
        " | sudo tee /etc/cron.daily/pac-update
    #S'il n'y a pas eu de fichier de log de rentré on commente le log de la sortie de la commande de mise à jour.
    [ -z $_logfile ] && sudo sed -e s/"2>> \$_LOGFILE ; cleanlog"/"#2> \$_LOGFILE ; cleanlog"/ -i /etc/cron.daily/pac-update
    sudo chmod 755 /etc/cron.daily/pac-update #On rend cette tache executable.
    fi

;;

* )
#Affiche le nom du script en fonction du fait qu'il se trouve dans la variable d'environnement PATH" ou pas.
if which $(basename $0) &> /dev/null
then
    _name=$(basname $0)
else
    _name=$0
fi

echo "
Usage :
$0 [-r] [-k] [-c]

Description :
$(basename $0)    est un script bash permettant de notifier la disponibilité de nouvelles mises à jour.
Il attend qu'un des gestionnaires de pacquage (cela peut être pacman ou yaourt) soit utilisé puis fermé.
Ensuite il vérifie si le nombre de mise à jour disponible à changé puis le notifie.
Si vous cliquer sur l'icône de notification et s'il y a des mises à jour il vous proposera de les installer,
si non il vous proposera de mètre à jour la base de donnée des paquet affin de vérifier l'existence de nouvelles
mises à jour. Ce script est prévu pour ce lancer comme un demon au lancement d'une session utilisateur graphique.
Lancé le dans votre xinirc ou ce qu'il convient selon l'environnement de bureau que vous utilisé. N'oublier pas
de vérifier que le script est bien exécutable. Pour être avertie automatiquement de nouvelles mise à jour le
mieux est d'avoir un tache cron prévu à cette effet, si vous n'en avez pas regardez au niveau de l'option \"-c\".

Option : 
  -r, --run         Permet de démarrer un instance de ce script, si une instance est déjà en cour la nouvelle replacera la
précédente, ce qui est utile en cas de modification de la configuration du script.

  -k, --kill            À utiliser pour arrêter ce script. Celui ci lance divers sous processus qui ne seront pas stoppé avec
une commande comme \"killall $(basename $0)\".

  -c, --create-cron  Permet de crée une tache cron.daily affin de mètre à jour quotidiennement la base de donné de pacam
ainsi vous serez prévenus automatiquement lors de nouvelles mises à jour.

Configuration :
Divers option de configuration sont disponibles à l'intérieur du script lui même. Elles ce situe dans la partie \"CONFIGURATION\"
en début de script. Vous pourrez par exemples paramétrer les commandes de mise à jour, lui demander de jouer un son afin de
vous prévenir en cas de nouvelles mises à jour et y paramétrer des icônes pour les notification."

;;

esac


exit 0

[tuxce]

Salut, si je peux me permettre, quelques remarques et questions

je comprends pas bien l'intérêt de lancer la mise à jour de la base ou des paquets en arrière plan, de toute façon, tu attends la fin de l'exécution, non ?
La manière dont t'attends la fin d'exécution peut provoquer des erreurs, par exemple dans le scénario suivant:
- ton script lance une maj (de base ou de paquet)
- l'utilisateur ou un cron ou peu importe lance une action pacman quelconque dans un terminal
- l'action se termine
- ton script va détecter la fermeture de pacman + le terminal alors que c'est pas ceux lancés par ton script

propositions:

Code : Tout sélectionner

# Pour ne récupérer que les noms des paquets:
pacman -Qqu
# Pour ne lancer qu'une seule fois la commande:
majs=($(pacman -Qqu))
echo "nombre: ${#majs[@]}"
echo "liste: ${majs[@]}"
# Pour détecter l'exécution de pacman (en mode blocage) ou tout autre wrapper:
while [[ -f /var/lib/pacman/db.lck ]]; do sleep 3; done
# zenity retourne un code erreur bien particulier lors d'un kill : 143
(
k=1
while ((k)); do
	zenity --notification --title="toto" --text="coucou"
	(($?==143)) && break
	zenity --question --title="toto" --text="oui/non?"
	k=$?
done
) &
pid=$!
# plein de commandes ou autre
# et une fois qu'on veut quitter le sous shell
pkill -P $pid

Tu peux aussi utiliser trap pour être sûr de fermer les processus fils.
Sinon une boucle infini sans sleep, je sais pas, ça me fait bizarre ... enfin ça reste de propositions

[00001000]

Merci pour avoir copier mon script, j'étais pas au courent pour pastbin, et merci pour le conseil, ils sont constructif.

Je vais apporter quelques précision :
La commande de mise à jour est lancé en arrière plan car je veux que les commande de notification au dessous s’exécute en même temps affin de notifier qu'une mise à jour est en cours.
En ce qui concerne ton scénario, si j'ai bien compris, cela ne peut normalement pas ce produire car le script attendra le fermeture du terminal qu'il à lancé et pas d'un autres pour continuer. Il est bloquer par cette commande :

Code : Tout sélectionner

267                 while [ ! -z $(ps -x -o"%p %c" | grep "$(pgrep -P $(pidof -x pacgum | sed "s/ /,/g"))" | grep ${_TERMCMD%%-*} | awk '{print $1}') ]
268                 do
269                         inotifywait -e close $(which ${_TERMCMD%%-*})
270                 done

Tant que le terminal servant au mises à jour existe il ne continuera pas et ce n'est pas la fermeture d'un autres terminal qui pourra le valider.

J'ai porter beaucoup d’intérêt à tes suggestion :

Code : Tout sélectionner

majs=($(pacman -Qqu))
echo "nombre: ${#majs[@]}"
echo "liste: ${majs[@]}"

C'est en effet bien plus simple comme ça, mais je n'y avais pas penser.

Code : Tout sélectionner

while [[ -f /var/lib/pacman/db.lck ]]; do sleep 3; done

Je ne connaissais pas l’existence de ce fichier.

Si j'ai bien compris le but du reste du code que ta mis cela me paramétrerais de notifier "mise à jour en cour" n'importe quand a partir du moment ou une mise a jour de pacman ou équivalant est lancé et pas seulement celle du script, ça préviendrais même l'exécution de de commande lancé par cron et éviterais deux exécution simultané. C'est intéressant, ça non plus j'y aurais pas penser, en plus ta trouvé ça tellement vite alors que moi j'en ai chier à faire ce script . C'est ce qu'ont doit appeler l’expérience je crois .

De plus je ne connaissait pas l’existante d'une commande comme trap qui offre beaucoup de possibilité.
Et pour finir en ce qui concerne la boucle, tu doit sûrement parler le selle de la function execcmd mais je ne vois pas en quois un sleep serais utile ici.

Je pense qu'avec ces suggestion je peut faire quelque chose de bien mieux, mais ce ne sera par pour tous de suite car je suis repartit sur autres chose. Mais de touts façon il fonctionne déjà bien, avant de le publier je l'ai tester dans divers situation et je n'ai pas trouver de problème, après j'ai peut être oublier des choses.

Une suite viendra ...

[tuxce]

Code : Tout sélectionner

inotifywait -e close $(which ${_TERMCMD%%-*})

L'événement "close" ne se produit pas forcément seulement à la fin d'une exécution, ok, tu utilises par défaut xterm, mais il peut aussi être utilisé par l'utilisateur, le fermer déclenchera le "close", un programme qui scan le disque ou plein d'autres scénario peuvent provoquer le "close" et faire agir ton script comme si le terminal que t'as lancé s'est fermé.
La fonction pourrait être la suivante:

Code : Tout sélectionner

execcmd(){
    while true
    do
        zenity --notification $_IMGEXECUPDATE --title="$(basename $0)" --text="$2"
        (($?==143)) && break
        zenity --info --title="$(basename $0)" --text="$2"
    done &
    pid=$!
    $_TERMCMD "echo \"==> Entrez votre mots de passe pour $_UPDATECMD $1 :\" ; sudo $_UPDATECMD $1 ; read -p \"==> Appuyez sur entrée pour continuer ...\"" || logerr "Erreur au lancement de la commande \"execcmd\".\nVeillez vérifier celle-ci dans la parie configuration de ce script." "exit $_BADCMD" 
    pkill -P $pid
}

En gros, je pense qu'il vaut mieux être sûr de ce que tu kill plutôt qu'essayer de deviner avec le moins de casse

[00001000]

Inverser la boucle et la commande c'est vrais que c'est tellement plus simple, propre et efficace comme ça.
Et dire que je m'étais pris la tête à mettre ce système en place et je n'y avais même pas pensé.
Je referais une version dans quelques temps car je n'ai plus de temps à consacré à ce script mais avec les conseil que tu m'a donné je ferais sûrement quelque chose de bien mieux.

Merci.

Il faut avouer que c'est quand même frustrant de voir quelqu'un trouver en 3 seconde une solution à un problème qui m'a pris beaucoup de temps, mais bon je doit considérer encore comme un débutant.
Dalleur le simple fait de rédiger ce script, m'a déjà beaucoup appris, me faut encore pratiquer.