Voglio che il mio script bash dorma fino a un orario specifico. Quindi, voglio un comando come "sleep" che non richiede intervalli ma un'ora di fine e rimane inattivo fino ad allora.
Il demone "at" non è una soluzione, poiché ho bisogno di bloccare uno script in esecuzione fino a una certa data / ora.
Esiste un tale comando?
Risposte:
Come accennato da Outlaw Programmer, penso che la soluzione sia solo dormire per il numero corretto di secondi.
Per farlo in bash, procedi come segue:
current_epoch=$(date +%s)
target_epoch=$(date -d '01/01/2010 12:00' +%s)
sleep_seconds=$(( $target_epoch - $current_epoch ))
sleep $sleep_seconds
Per aggiungere precisione fino a nanosecondi (effettivamente più intorno ai millisecondi) usa ad esempio questa sintassi:
current_epoch=$(date +%s.%N)
target_epoch=$(date -d "20:25:00.12345" +%s.%N)
sleep_seconds=$(echo "$target_epoch - $current_epoch"|bc)
sleep $sleep_seconds
Nota che macOS / OS X non supporta la precisione al di sotto dei secondi, dovresti invece usare coreutilsda brew→ vedi queste istruzioni
target_epoch=$(date -d 'tomorrow 03:00' +%s)invece.
dateinvece di due! Vedi la prima parte della mia risposta
Poiché questa domanda è stata posta 4 anni fa, questa prima parte riguarda le vecchie versioni di bash:
Ultima modifica: mercoledì 22 aprile 2020, tra le 10:30 e le 10:55 (importante per la lettura di campioni)
(Nota: questo metodo usa date -fche non è POSIX e non funziona con MacOS! Se sotto Mac, vai al mio purebashfunzione )
Per ridurre forks, invece di correre datedue volte, preferisco usare questo:
sleep $(($(date -f - +%s- <<< $'tomorrow 21:30\nnow')0))
dove tomorrow 21:30potrebbe essere sostituito da qualsiasi tipo di data e formato riconosciuto da date, in futuro.
Quasi lo stesso:
sleep $(bc <<<s$(date -f - +'t=%s.%N;' <<<$'07:00 tomorrow\nnow')'st-t')
Per raggiungere il prossimoHH:MM significato oggi se possibile, domani se troppo tardi:
sleep $((($(date -f - +%s- <<<$'21:30 tomorrow\nnow')0)%86400))
Questo funziona sotto bash, ksh e altre shell moderne, ma devi usare:
sleep $(( ( $(printf 'tomorrow 21:30\nnow\n' | date -f - +%s-)0 )%86400 ))
sotto accendino conchiglie comecenere o trattino.
Testato su MacOS!
Ho scritto una due piccole funzioni: sleepUntilesleepUntilHires
Syntax:
sleepUntil [-q] <HH[:MM[:SS]]> [more days]
-q Quiet: don't print sleep computed argument
HH Hours (minimal required argument)
MM Minutes (00 if not set)
SS Seconds (00 if not set)
more days multiplied by 86400 (0 by default)
Poiché le nuove versioni di bash offrono printfun'opzione per recuperare la data, per questo nuovo modo di dormire fino a HH: MM senza usare dateo qualsiasi altro fork, ho costruito un po 'bashfunzione. Ecco qui:
sleepUntil() { # args [-q] <HH[:MM[:SS]]> [more days]
local slp tzoff now quiet=false
[ "$1" = "-q" ] && shift && quiet=true
local -a hms=(${1//:/ })
printf -v now '%(%s)T' -1
printf -v tzoff '%(%z)T\n' $now
tzoff=$((0${tzoff:0:1}(3600*${tzoff:1:2}+60*${tzoff:3:2})))
slp=$((
( 86400+(now-now%86400) + 10#$hms*3600 + 10#${hms[1]}*60 +
${hms[2]}-tzoff-now ) %86400 + ${2:-0}*86400
))
$quiet || printf 'sleep %ss, -> %(%c)T\n' $slp $((now+slp))
sleep $slp
}
Poi:
sleepUntil 10:37 ; date +"Now, it is: %T"
sleep 49s, -> Wed Apr 22 10:37:00 2020
Now, it is: 10:37:00
sleepUntil -q 10:37:44 ; date +"Now, it is: %T"
Now, it is: 10:37:44
sleepUntil 10:50 1 ; date +"Now, it is: %T"
sleep 86675s, -> Thu Apr 23 10:50:00 2020
^C
Se l'obiettivo è prima , dormirà fino a domani:
sleepUntil 10:30 ; date +"Now, it is: %T"
sleep 85417s, -> Thu Apr 23 10:30:00 2020
^C
sleepUntil 10:30 1 ; date +"Now, it is: %T"
sleep 171825s, -> Fri Apr 24 10:30:00 2020
^C
Recente bash, dalla versione 5.0 aggiungi una nuova $EPOCHREALTIMEvariabile con microsecondi. Da questo c'è una sleepUntilHiresfunzione.
sleepUntilHires () { # args [-q] <HH[:MM[:SS]]> [more days]
local slp tzoff now quiet=false musec musleep;
[ "$1" = "-q" ] && shift && quiet=true;
local -a hms=(${1//:/ });
printf -v now '%(%s)T' -1;
IFS=. read now musec <<< $EPOCHREALTIME;
musleep=$[2000000-10#$musec];
printf -v tzoff '%(%z)T\n' $now;
tzoff=$((0${tzoff:0:1}(3600*${tzoff:1:2}+60*${tzoff:3:2})));
slp=$(((( 86400 + ( now - now%86400 ) +
10#$hms*3600+10#${hms[1]}*60+10#${hms[2]} -
tzoff - now - 1
) % 86400 ) + ${2:-0} * 86400
)).${musleep:1};
$quiet || printf 'sleep %ss, -> %(%c)T\n' $slp $((now+${slp%.*}+1));
read -t $slp foo
}
Nota: questo uso read -tche è integrato, invece di sleep. Sfortunatamente, questo non funzionerà durante l'esecuzione in background, senza un vero TTY. Sentiti libero di sostituire read -tcon sleepse prevedi di eseguirlo in script in background ... (Ma per il processo in background, considera l'utilizzo crone / o al atposto di tutto questo)
Salta il paragrafo successivo per i test e le avvertenze $ËPOCHSECONDS!
/proc/timer_listda parte dell'utente !!(L'ho scritto per generare e tenere traccia di eventi specifici su file di registro molto grandi, contenenti migliaia di righe per un secondo).
mapfile </proc/timer_list _timer_list
for ((_i=0;_i<${#_timer_list[@]};_i++));do
[[ ${_timer_list[_i]} =~ ^now ]] && TIMER_LIST_SKIP=$_i
[[ ${_timer_list[_i]} =~ offset:.*[1-9] ]] && \
TIMER_LIST_OFFSET=${_timer_list[_i]//[a-z.: ]} && \
break
done
unset _i _timer_list
readonly TIMER_LIST_OFFSET TIMER_LIST_SKIP
sleepUntilHires() {
local slp tzoff now quiet=false nsnow nsslp
[ "$1" = "-q" ] && shift && quiet=true
local hms=(${1//:/ })
mapfile -n 1 -s $TIMER_LIST_SKIP nsnow </proc/timer_list
printf -v now '%(%s)T' -1
printf -v tzoff '%(%z)T\n' $now
nsnow=$((${nsnow//[a-z ]}+TIMER_LIST_OFFSET))
nsslp=$((2000000000-10#${nsnow:${#nsnow}-9}))
tzoff=$((0${tzoff:0:1}(3600*${tzoff:1:2}+60*${tzoff:3:2})))
slp=$(( ( 86400 + ( now - now%86400 ) +
10#$hms*3600+10#${hms[1]}*60+${hms[2]} -
tzoff - now - 1
) % 86400)).${nsslp:1}
$quiet || printf 'sleep %ss, -> %(%c)T\n' $slp $((now+${slp%.*}+1))
sleep $slp
}
Dopo aver definito due variabili di sola letturaTIMER_LIST_OFFSET e TIMER_LIST_SKIP, la funzione accederà molto rapidamente al file delle variabili /proc/timer_listper il calcolo del tempo di sospensione:
tstSleepUntilHires () {
local now next last
printf -v next "%(%H:%M:%S)T" $((${EPOCHREALTIME%.*}+1))
sleepUntilHires $next
date -f - +%F-%T.%N < <(echo now;sleep .92;echo now)
printf -v next "%(%H:%M:%S)T" $((${EPOCHREALTIME%.*}+1))
sleepUntilHires $next
date +%F-%T.%N
}
Può rendere qualcosa come:
sleep 0.244040s, -> Wed Apr 22 10:34:39 2020
2020-04-22-10:34:39.001685312
2020-04-22-10:34:39.922291769
sleep 0.077012s, -> Wed Apr 22 10:34:40 2020
2020-04-22-10:34:40.004264869
$EPOCHSECONDe $EPOCHREALTIME!Leggi il mio avviso sulla differenza tra $EPOCHSECONDe$EPOCHREALTIME
Questa funzione viene utilizzata $EPOCHREALTIMEquindi non utilizzare $EPOCHSECONDper stabilire il secondo successivo :
Problema di esempio: tentativo di stampare l'ora successiva arrotondata di 2 secondi:
for i in 1 2;do
printf -v nextH "%(%T)T" $(((EPOCHSECONDS/2)*2+2))
sleepUntilHires $nextH
IFS=. read now musec <<<$EPOCHREALTIME
printf "%(%c)T.%s\n" $now $musec
done
Può produrre:
sleep 0.587936s, -> Wed Apr 22 10:51:26 2020
Wed Apr 22 10:51:26 2020.000630
sleep 86399.998797s, -> Thu Apr 23 10:51:26 2020
^C
%86400trucco funziona solo se i due tempi non coprono una transizione dell'ora legale.
tzoffnella mia risposta!
Usa sleep, ma calcola il tempo usando date. Ti consigliamo di usarlo date -dper questo. Ad esempio, supponiamo che tu voglia aspettare fino alla prossima settimana:
expr `date -d "next week" +%s` - `date -d "now" +%s`
Sostituisci "la prossima settimana" con la data che desideri attendere, quindi assegna a questa espressione un valore e dormi per tanti secondi:
startTime=$(date +%s)
endTime=$(date -d "next week" +%s)
timeToWait=$(($endTime- $startTime))
sleep $timeToWait
Tutto fatto!
-dè un'estensione non POSIX fino ad oggi. Su FreeBSD cerca di impostare il valore del kernel per l'ora legale.
Ecco una soluzione che fa il lavoro E informa l'utente su quanto tempo rimane. Lo uso quasi tutti i giorni per eseguire script durante la notte (usando cygwin, dato che non riuscivo crona lavorare su Windows)
&&$ til 13:00 && date
1 hour and 18 minutes and 26 seconds left...
1 hour and 18 minutes left...
1 hour and 17 minutes left...
1 hour and 16 minutes left...
1 hour and 15 minutes left...
1 hour and 14 minutes left...
1 hour and 10 minutes left...
1 hour and 5 minutes left...
1 hour and 0 minutes left...
55 minutes left...
50 minutes left...
45 minutes left...
40 minutes left...
35 minutes left...
30 minutes left...
25 minutes left...
20 minutes left...
15 minutes left...
10 minutes left...
5 minutes left...
4 minutes left...
3 minutes left...
2 minutes left...
1 minute left...
Mon, May 18, 2015 1:00:00 PM
(La data alla fine non fa parte della funzione, ma a causa del && date)
til(){
local hour mins target now left initial sleft correction m sec h hm hs ms ss showSeconds toSleep
showSeconds=true
[[ $1 =~ ([0-9][0-9]):([0-9][0-9]) ]] || { echo >&2 "USAGE: til HH:MM"; return 1; }
hour=${BASH_REMATCH[1]} mins=${BASH_REMATCH[2]}
target=$(date +%s -d "$hour:$mins") || return 1
now=$(date +%s)
(( target > now )) || target=$(date +%s -d "tomorrow $hour:$mins")
left=$((target - now))
initial=$left
while (( left > 0 )); do
if (( initial - left < 300 )) || (( left < 300 )) || [[ ${left: -2} == 00 ]]; then
# We enter this condition:
# - once every 5 minutes
# - every minute for 5 minutes after the start
# - every minute for 5 minutes before the end
# Here, we will print how much time is left, and re-synchronize the clock
hs= ms= ss=
m=$((left/60)) sec=$((left%60)) # minutes and seconds left
h=$((m/60)) hm=$((m%60)) # hours and minutes left
# Re-synchronise
now=$(date +%s) sleft=$((target - now)) # recalculate time left, multiple 60s sleeps and date calls have some overhead.
correction=$((sleft-left))
if (( ${correction#-} > 59 )); then
echo "System time change detected..."
(( sleft <= 0 )) && return # terminating as the desired time passed already
til "$1" && return # resuming the timer anew with the new time
fi
# plural calculations
(( sec > 1 )) && ss=s
(( hm != 1 )) && ms=s
(( h > 1 )) && hs=s
(( h > 0 )) && printf %s "$h hour$hs and "
(( h > 0 || hm > 0 )) && printf '%2d %s' "$hm" "minute$ms"
if [[ $showSeconds ]]; then
showSeconds=
(( h > 0 || hm > 0 )) && (( sec > 0 )) && printf %s " and "
(( sec > 0 )) && printf %s "$sec second$ss"
echo " left..."
(( sec > 0 )) && sleep "$sec" && left=$((left-sec)) && continue
else
echo " left..."
fi
fi
left=$((left-60))
sleep "$((60+correction))"
correction=0
done
}
È possibile interrompere l'esecuzione di un processo, inviandogli un segnale SIGSTOP, e quindi fargli riprendere l'esecuzione inviandogli un segnale SIGCONT.
Quindi potresti interrompere il tuo script inviando è un SIGSTOP:
kill -SIGSTOP <pid>
E poi usa il demone at per svegliarlo inviandogli un SIGCONT allo stesso modo.
Presumibilmente, il tuo copione informerà su quando voleva essere svegliato prima di addormentarsi.
Su Ubuntu 12.04.4 LTS ecco il semplice input bash che funziona:
sleep $(expr `date -d "03/21/2014 12:30" +%s` - `date +%s`)
Per seguire la risposta di SpoonMeiser, ecco un esempio specifico:
$cat ./reviveself
#!/bin/bash
# save my process ID
rspid=$$
# schedule my own resuscitation
# /bin/sh seems to dislike the SIGCONT form, so I use CONT
# at can accept specific dates and times as well as relative ones
# you can even do something like "at thursday" which would occur on a
# multiple of 24 hours rather than the beginning of the day
echo "kill -CONT $rspid"|at now + 2 minutes
# knock myself unconscious
# bash is happy with symbolic signals
kill -SIGSTOP $rspid
# do something to prove I'm alive
date>>reviveself.out
$
Volevo uno script che controllasse solo le ore ei minuti in modo da poter eseguire lo script con gli stessi parametri ogni giorno. Non voglio preoccuparmi di quale giorno sarà domani. Quindi ho usato un approccio diverso.
target="$1.$2"
cur=$(date '+%H.%M')
while test $target != $cur; do
sleep 59
cur=$(date '+%H.%M')
done
i parametri dello script sono le ore e i minuti, quindi posso scrivere qualcosa come:
til 7 45 && mplayer song.ogg
(finché è il nome della sceneggiatura)
non più giorni di ritardo al lavoro perché hai digitato male la giornata. Saluti!
timeToWait = $ (($ end - $ start))
Attenzione che "timeToWait" potrebbe essere un numero negativo! (ad esempio, se specifichi di dormire fino alle "15:57" e ora è "15:58"). Quindi devi controllarlo per evitare strani errori di messaggio:
#!/bin/bash
set -o nounset
### // Sleep until some date/time.
# // Example: sleepuntil 15:57; kdialog --msgbox "Backup needs to be done."
error() {
echo "$@" >&2
exit 1;
}
NAME_PROGRAM=$(basename "$0")
if [[ $# != 1 ]]; then
error "ERROR: program \"$NAME_PROGRAM\" needs 1 parameter and it has received: $#."
fi
current=$(date +%s.%N)
target=$(date -d "$1" +%s.%N)
seconds=$(echo "scale=9; $target - $current" | bc)
signchar=${seconds:0:1}
if [ "$signchar" = "-" ]; then
error "You need to specify in a different way the moment in which this program has to finish, probably indicating the day and the hour like in this example: $NAME_PROGRAM \"2009/12/30 10:57\"."
fi
sleep "$seconds"
# // End of file
SIGNCHAR=${SECONDS:0:1}e poi if [ "$SIGNCHAR" = "-" ]. Dovrebbe bastare.
Puoi calcolare il numero di secondi tra adesso e l'ora della sveglia e utilizzare il comando "sleep" esistente.
Potresti forse usare "at" per inviare un segnale al tuo script, che attendeva quel segnale.
In realtà ho scritto https://tamentis.com/projects/sleepuntil/ per questo scopo esatto. È un po 'eccessivo la maggior parte del codice proviene da BSD' at 'quindi è abbastanza conforme agli standard:
$ sleepuntil noon && sendmail something
Ecco qualcosa che ho scritto poco fa per sincronizzare più client di prova:
#!/usr/bin/python
import time
import sys
now = time.time()
mod = float(sys.argv[1])
until = now - now % mod + mod
print "sleeping until", until
while True:
delta = until - time.time()
if delta <= 0:
print "done sleeping ", time.time()
break
time.sleep(delta / 2)
Questo script rimane inattivo fino al prossimo tempo "arrotondato" o "nitido".
Un semplice caso d'uso consiste ./sleep.py 10; ./test_client1.pynell'eseguire in un terminale e ./sleep.py 10; ./test_client2.pyin un altro.
untilsia impostato su una data / ora specifica
function sleepuntil() {
local target_time="$1"
today=$(date +"%m/%d/%Y")
current_epoch=$(date +%s)
target_epoch=$(date -d "$today $target_time" +%s)
sleep_seconds=$(( $target_epoch - $current_epoch ))
sleep $sleep_seconds
}
target_time="11:59"; sleepuntil $target_time
Ho messo insieme una piccola utility chiamata Hypnos per farlo. È configurato utilizzando la sintassi crontab e blocca fino a quel momento.
#!/bin/bash
while [ 1 ]; do
hypnos "0 * * * *"
echo "running some tasks..."
# ...
done
Per estendere la risposta principale, ecco alcuni validi esempi riguardanti la manipolazione della stringa di data:
sleep $(($(date -f - +%s- <<< $'+3 seconds\nnow')0)) && ls
sleep $(($(date -f - +%s- <<< $'3 seconds\nnow')0)) && ls
sleep $(($(date -f - +%s- <<< $'3 second\nnow')0)) && ls
sleep $(($(date -f - +%s- <<< $'+2 minute\nnow')0)) && ls
sleep $(($(date -f - +%s- <<< $'tomorrow\nnow')0)) && ls
sleep $(($(date -f - +%s- <<< $'tomorrow 21:30\nnow')0)) && ls
sleep $(($(date -f - +%s- <<< $'3 weeks\nnow')0)) && ls
sleep $(($(date -f - +%s- <<< $'3 week\nnow')0)) && ls
sleep $(($(date -f - +%s- <<< $'next Friday 09:00\nnow')0)) && ls
sleep $(($(date -f - +%s- <<< $'2027-01-01 00:00:01 UTC +5 hours\nnow')0)) && ls
Su OpenBSD , è possibile utilizzare quanto segue per compattare un lavoro di */55 minuti crontab(5)in uno 00orario (per assicurarsi che vengano generati meno messaggi di posta elettronica, tutti eseguendo la stessa attività a intervalli esatti):
#!/bin/sh -x
for k in $(jot 12 00 55)
do
echo $(date) doing stuff
sleep $(expr $(date -j +%s $(printf %02d $(expr $k + 5))) - $(date -j +%s))
done
Si noti che date(1)interromperà il sleep(1)by design anche nell'iterazione finale, poiché i 60minuti non sono un tempo valido (a meno che non lo sia!), Quindi non dovremo aspettare altro tempo prima di ricevere il nostro rapporto e-mail.
Si noti inoltre che se una delle iterazioni richiede più di 5 minuti assegnati, il file sleep stesso modo fallirebbe gentilmente per progettazione non dormendo affatto (a causa di quello che è un numero negativo interpretato come un'opzione della riga di comando, invece di avvolgere a l'ora successiva o anche l'eternità), assicurandoti così che il tuo lavoro possa ancora essere completato entro l'ora assegnata (ad esempio, se solo una delle iterazioni richiede un po 'più di 5 minuti, allora avremmo ancora il tempo di recuperare, senza tutto ciò che va a finire all'ora successiva).
Il printf(1)è necessario perché datesi aspetta esattamente due cifre per la specifica minuto.
Usa tarry. È uno strumento che ho scritto appositamente per farlo.
https://github.com/metaphyze/tarry/
Questo è un semplice strumento da riga di comando per attendere fino a un momento specifico. Non è la stessa cosa del "sonno" che aspetterà per un certo periodo di tempo. Ciò è utile se si desidera eseguire qualcosa in un momento specifico o più probabilmente eseguire più cose esattamente nello stesso momento, ad esempio testare se un server può gestire più richieste molto simultanee. Puoi usarlo in questo modo con "&&" su Linux, Mac o Windows:
tarry -until=16:03:04 && someOtherCommand
Questo aspetterebbe fino alle 16:03:04 e quindi eseguirà un altro comando. Ecco un esempio Linux / Mac di come eseguire più richieste tutte programmate per l'avvio allo stesso tempo:
for request in 1 2 3 4 5 6 7 8 9 10
do
tarry -until=16:03:04 && date > results.$request &
done
I binari di Ubuntu, Linux e Windows sono disponibili tramite i collegamenti nella pagina.