Linux :commande de planification à exécuter une fois après le redémarrage (équivalent RunOnce)

Solution 1 :

Créer un @reboot entrée dans votre crontab pour exécuter un script appelé /usr/local/bin/runonce .

Créez une structure de répertoire appelée /etc/local/runonce.d/ran en utilisant mkdir -p .

Créez le script /usr/local/bin/runonce comme suit :

#!/bin/sh
for file in /etc/local/runonce.d/*
do
    if [ ! -f "$file" ]
    then
        continue
    fi
    "$file"
    mv "$file" "/etc/local/runonce.d/ran/$file.$(date +%Y%m%dT%H%M%S)"
    logger -t runonce -p local3.info "$file"
done

Placez maintenant tout script que vous souhaitez exécuter au prochain redémarrage (une seule fois) dans le répertoire /etc/local/runonce.d et chown et chmod +x de manière appropriée. Une fois qu'il a été exécuté, vous le trouverez déplacé vers le ran sous-répertoire et la date et l'heure ajoutées à son nom. Il y aura également une entrée dans votre syslog .

Solution 2 :

J'apprécie vraiment l'effort mis dans la réponse de Dennis Williamson. Je voulais l'accepter comme réponse à cette question, car elle est élégante et simple, cependant :

• J'ai finalement estimé que la configuration nécessitait trop d'étapes.
• Cela nécessite un accès root.

Je pense que sa solution serait géniale en tant que fonctionnalité prête à l'emploi d'une distribution Linux.

Cela étant dit, j'ai écrit mon propre script pour accomplir plus ou moins la même chose que la solution de Dennis. Il ne nécessite aucune étape de configuration supplémentaire et ne nécessite pas d'accès root.

#!/bin/bash

if [[ $# -eq 0 ]]; then
    echo "Schedules a command to be run after the next reboot."
    echo "Usage: $(basename $0) <command>"
    echo "       $(basename $0) -p <path> <command>"
    echo "       $(basename $0) -r <command>"
else
    REMOVE=0
    COMMAND=${!#}
    SCRIPTPATH=$PATH

    while getopts ":r:p:" optionName; do
        case "$optionName" in
            r) REMOVE=1; COMMAND=$OPTARG;;
            p) SCRIPTPATH=$OPTARG;;
        esac
    done

    SCRIPT="${HOME}/.$(basename $0)_$(echo $COMMAND | sed 's/[^a-zA-Z0-9_]/_/g')"

    if [[ ! -f $SCRIPT ]]; then
        echo "PATH=$SCRIPTPATH" >> $SCRIPT
        echo "cd $(pwd)"        >> $SCRIPT
        echo "logger -t $(basename $0) -p local3.info \"COMMAND=$COMMAND ; USER=\$(whoami) ($(logname)) ; PWD=$(pwd) ; PATH=\$PATH\"" >> $SCRIPT
        echo "$COMMAND | logger -t $(basename $0) -p local3.info" >> $SCRIPT
        echo "$0 -r \"$(echo $COMMAND | sed 's/\"/\\\"/g')\""     >> $SCRIPT
        chmod +x $SCRIPT
    fi

    CRONTAB="${HOME}/.$(basename $0)_temp_crontab_$RANDOM"
    ENTRY="@reboot $SCRIPT"

    echo "$(crontab -l 2>/dev/null)" | grep -v "$ENTRY" | grep -v "^# DO NOT EDIT THIS FILE - edit the master and reinstall.$" | grep -v "^# ([^ ]* installed on [^)]*)$" | grep -v "^# (Cron version [^$]*\$[^$]*\$)$" > $CRONTAB

    if [[ $REMOVE -eq 0 ]]; then
        echo "$ENTRY" >> $CRONTAB
    fi

    crontab $CRONTAB
    rm $CRONTAB

    if [[ $REMOVE -ne 0 ]]; then
        rm $SCRIPT
    fi
fi

Enregistrez ce script (ex :runonce ), chmod +x , et exécutez :

$ runonce foo
$ runonce "echo \"I'm up. I swear I'll never email you again.\" | mail -s \"Server's Up\" $(whoami)"

En cas de faute de frappe, vous pouvez supprimer une commande de la file d'attente runonce avec le drapeau -r :

$ runonce fop
$ runonce -r fop
$ runonce foo

L'utilisation de sudo fonctionne comme vous vous y attendez. Utile pour démarrer un serveur une seule fois après le prochain redémarrage.

[email protected]:/home/myuser$ sudo runonce foo
[email protected]:/home/myuser$ sudo crontab -l
# DO NOT EDIT THIS FILE - edit the master and reinstall.
# (/root/.runonce_temp_crontab_10478 installed on Wed Jun  9 16:56:00 2010)
# (Cron version V5.0 -- $Id: crontab.c,v 1.12 2004/01/23 18:56:42 vixie Exp $)
@reboot /root/.runonce_foo
[email protected]:/home/myuser$ sudo cat /root/.runonce_foo
PATH=/usr/sbin:/bin:/usr/bin:/sbin
cd /home/myuser
foo
/home/myuser/bin/runonce -r "foo"

Quelques remarques :

• Ce script réplique l'environnement (PATH, répertoire de travail, utilisateur) dans lequel il a été invoqué.
• Il est conçu pour différer l'exécution d'une commande telle qu'elle serait exécutée "ici, maintenant" jusqu'à la prochaine séquence de démarrage.

Solution 3 :

Créer par ex. /root/runonce.sh :

#!/bin/bash
#your command here
sed -i '/runonce.sh/d' /etc/rc.local

Ajouter à /etc/rc.local :

/root/runonce.sh

Solution 4 :

J'ai utilisé chkconfig pour que mon système exécute automatiquement un script une fois après le démarrage et plus jamais. Si votre système utilise ckconfig (Fedora, RedHat, CentOs, etc.), cela fonctionnera.

D'abord le script :

#!/bin/bash
# chkconfig: 345 99 10
# description: This script is designed to run once and then never again.
#


##
# Beginning of your custom one-time commands
#

plymouth-set-default-theme charge -R
dracut -f

#
# End of your custom one-time commands
##


##
# This script will run once
# If you would like to run it again.  run 'chkconfig run-once on' then reboot.
#
chkconfig run-once off
chkconfig --del run-once

1. Nommez le script run-once
2. Placez le script en /etc/init.d/
3. Activer le script chkconfig run-once on
4. redémarrer

Lorsque le système démarre, votre script s'exécute une fois et plus jamais.

Autrement dit, plus jamais à moins que vous ne le vouliez. Vous pouvez toujours réactiver le script avec le chkconfig run-once on commande.

J'aime cette solution car elle place un et un seul fichier sur le système et parce que la commande run-once peut être ré-émise si nécessaire.

Solution 5 :

Configurez le script dans /etc/rc5.d avec un S99 et faites-le se supprimer après l'exécution.