Linux:comando di pianificazione da eseguire una volta dopo il riavvio (equivalente a RunOnce)

Soluzione 1:

Crea un @reboot voce nel tuo crontab per eseguire uno script chiamato /usr/local/bin/runonce .

Crea una struttura di directory chiamata /etc/local/runonce.d/ran usando mkdir -p .

Crea lo script /usr/local/bin/runonce come segue:

#!/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

Ora posiziona qualsiasi script che vuoi eseguire al prossimo riavvio (una sola volta) nella directory /etc/local/runonce.d e chown e chmod +x in modo appropriato. Una volta eseguito, lo troverai spostato in ran sottodirectory e la data e l'ora aggiunte al suo nome. Ci sarà anche una voce nel tuo syslog .

Soluzione 2:

Apprezzo molto lo sforzo profuso nella risposta di Dennis Williamson. Ho voluto accettarla come risposta a questa domanda, in quanto è comunque elegante e semplice:

• Alla fine ho pensato che la configurazione richiedesse troppi passaggi.
• Richiede l'accesso root.

Penso che la sua soluzione sarebbe ottima come caratteristica pronta all'uso di una distribuzione Linux.

Detto questo, ho scritto la mia sceneggiatura per realizzare più o meno la stessa cosa della soluzione di Dennis. Non richiede passaggi di configurazione aggiuntivi e non richiede l'accesso come 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

Salva questo script (ad esempio:runonce ), chmod +x , ed esegui:

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

In caso di errore di battitura, puoi rimuovere un comando dalla coda runonce con il flag -r:

$ runonce fop
$ runonce -r fop
$ runonce foo

L'uso di sudo funziona nel modo in cui ti aspetteresti che funzioni. Utile per avviare un server solo una volta dopo il successivo riavvio.

[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"

Alcune note:

• Questo script replica l'ambiente (PERCORSO, directory di lavoro, utente) in cui è stato richiamato.
• È progettato sostanzialmente per rinviare l'esecuzione di un comando poiché verrebbe eseguito "proprio qui, adesso" fino a dopo la successiva sequenza di avvio.

Soluzione 3:

Crea ad es. /root/runonce.sh :

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

Aggiungi a /etc/rc.local :

/root/runonce.sh

Soluzione 4:

Ho usato chkconfig per fare in modo che il mio sistema esegua automaticamente uno script una volta dopo l'avvio e mai più. Se il tuo sistema utilizza ckconfig (Fedora, RedHat, CentOs, ecc.) funzionerà.

Prima lo 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. Nomina lo script run-once
2. Inserisci lo script in /etc/init.d/
3. Abilita lo script chkconfig run-once on
4. riavvia

Quando il sistema si avvia, il tuo script verrà eseguito una volta e mai più.

Cioè, mai più a meno che tu non lo voglia. Puoi sempre riattivare lo script con chkconfig run-once on comando.

Mi piace questa soluzione perché inserisce un solo file nel sistema e perché il comando run-once può essere riemesso se necessario.

Soluzione 5:

Imposta lo script in /etc/rc5.d con un S99 e fallo cancellare da solo dopo l'esecuzione.