Я хочу, щоб мій скрипт bash спав до певного часу. Отже, я хочу команду на кшталт "сплячий", яка займає не інтервал, а час закінчення і до цього часу спить.
Демон "at" не є рішенням, оскільки мені потрібно заблокувати запущений сценарій до певної дати / часу.
Чи існує така команда?
Відповіді:
Як згадував програміст Outlaw, я думаю, що рішення полягає лише в тому, щоб спати правильну кількість секунд.
Для цього в bash виконайте наступне:
current_epoch=$(date +%s)
target_epoch=$(date -d '01/01/2010 12:00' +%s)
sleep_seconds=$(( $target_epoch - $current_epoch ))
sleep $sleep_seconds
Щоб додати точність до наносекунд (фактично більше приблизно мілісекунд), використовуйте, наприклад, такий синтаксис:
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
Зверніть увагу , що MacOS / OS X не підтримує точність нижче секунд, вам потрібно буде використовувати coreutilsз brewзамість → побачити ці інструкції
target_epoch=$(date -d 'tomorrow 03:00' +%s)замість цього можете скористатися .
dateзамість двох! Дивіться першу частину моєї відповіді
Оскільки це питання було задано 4 роки тому, ця перша частина стосується старих версій bash:
Останнє редагування: середа, 22 квітня 2020 р., Щось між 10:30 та 10h: 55 (важливо для читання зразків)
(Примітка: цей метод використовує, date -fякий не є POSIX, і не працює під MacOS! Якщо під Mac, перейдіть до мого чистогобашфункція )
Для того, щоб зменшити forks, замість того, щоб запускати dateдва рази, я вважаю за краще використовувати це:
sleep $(($(date -f - +%s- <<< $'tomorrow 21:30\nnow')0))
де tomorrow 21:30можуть бути замінені будь-якими датами та форматами, визнаними dateв майбутньому.
Майже те саме:
sleep $(bc <<<s$(date -f - +'t=%s.%N;' <<<$'07:00 tomorrow\nnow')'st-t')
Для досягнення наступногоHH:MM значення сьогодні, якщо це можливо, завтра, якщо пізно:
sleep $((($(date -f - +%s- <<<$'21:30 tomorrow\nnow')0)%86400))
Це працює під баш, кш та інші сучасні оболонки, але ви повинні використовувати:
sleep $(( ( $(printf 'tomorrow 21:30\nnow\n' | date -f - +%s-)0 )%86400 ))
під легшими снарядами, якзола або тире.
Перевірено під MacOS!
Я написав одну дві маленькі функції: sleepUntilіsleepUntilHires
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)
Оскільки нові версії bash пропонують printfможливість отримати дату, для цього нового способу сну до HH: MM без використання dateабо будь-якої іншої вилки, я трохи побудувавбашфункція. Ось:
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
}
Тоді:
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
Якщо ціль до цього, це буде спати до завтра:
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
Останні баш, з версії 5.0 додати нову $EPOCHREALTIMEзмінну з мікросекундами. З цього є sleepUntilHiresфункція.
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
}
Зверніть увагу: це використання, read -tяке вбудоване, а не sleep. На жаль, це не спрацює під час роботи у фоновому режимі без реального TTY. Не соромтеся замінити read -tна, sleepякщо ви плануєте запустити це у фонових скриптах ... (Але для фонового процесу подумайте про використання cronта / або atзамість всього цього)
Пропустити наступний абзац для тестів та попередження про $ËPOCHSECONDS!
/proc/timer_listкористувачем !!(Я написав це для створення та відстеження конкретних подій у дуже великих файлах журналів, що містять тисячу рядків за одну секунду).
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
}
Після визначення двох змінних, доступних лише для читання , TIMER_LIST_OFFSETі TIMER_LIST_SKIP, функція дуже швидко отримає доступ до файлу змінної /proc/timer_listдля обчислення часу сну:
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
}
Може зробити щось на зразок:
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
$EPOCHSECONDі $EPOCHREALTIME!Прочитайте моє попередження про різницю між $EPOCHSECONDі$EPOCHREALTIME
Використання цієї функції, $EPOCHREALTIMEтому не використовуйте $EPOCHSECONDдля встановлення наступної секунди :
Зразок випуску: Спроба друкувати час, округлений на 2 секунди:
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
Може виробляти:
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
Використовуйте sleep, але обчисліть час, використовуючи date. Ви захочете використовувати date -dдля цього. Наприклад, скажімо, ви хотіли почекати до наступного тижня:
expr `date -d "next week" +%s` - `date -d "now" +%s`
Просто підставте "наступний тиждень" будь-якою датою, на яку ви хочете дочекатися, потім призначте цей вираз значенню і спати стільки секунд:
startTime=$(date +%s)
endTime=$(date -d "next week" +%s)
timeToWait=$(($endTime- $startTime))
sleep $timeToWait
Все зроблено!
-d- це розширення, яке не є POSIX на сьогоднішній день. На FreeBSD він намагається встановити значення ядра для переходу на літній час.
Ось рішення, яке виконує роботу І інформує користувача про те, скільки часу залишається. Я використовую його майже щодня для запуску скриптів протягом ночі (використовуючи cygwin, оскільки я не міг cronпрацювати на вікнах)
&&$ 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
(Дата в кінці не є частиною функції, але з - за && 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
}
Ви можете зупинити виконання процесу, надіславши йому сигнал SIGSTOP, а потім змусити його відновити виконання, надіславши йому сигнал SIGCONT.
Таким чином, ви можете зупинити свій сценарій, надіславши SIGSTOP:
kill -SIGSTOP <pid>
А потім використовуйте at deamon, щоб пробудити його, надіславши йому SIGCONT таким же чином.
Імовірно, ваш сценарій повідомляє про те, коли його хотіли прокинути, перед тим як заснути.
Щоб продовжити відповідь SpoonMeiser, ось конкретний приклад:
$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
$
Мені потрібен сценарій, який перевіряв би лише години та хвилини, щоб я міг запускати сценарій із однаковими параметрами щодня. Я не хочу хвилюватись, який день буде завтра. Тож я застосував інший підхід.
target="$1.$2"
cur=$(date '+%H.%M')
while test $target != $cur; do
sleep 59
cur=$(date '+%H.%M')
done
Параметри сценарію - це години та хвилини, тому я можу написати щось на зразок:
til 7 45 && mplayer song.ogg
(til - це назва сценарію)
не більше днів запізнення на роботу, тому що ви неправильно ввели день. ура!
timeToWait = $ (($ end - $ start))
Пам'ятайте, що "timeToWait" може мати від’ємне число! (наприклад, якщо ви вказали спати до "15:57", а зараз "15:58"). Тож вам доведеться це перевірити, щоб уникнути дивних помилок повідомлення:
#!/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}а потім if [ "$SIGNCHAR" = "-" ]. Це має зробити це.
Ви можете розрахувати кількість секунд від теперішнього часу до часу пробудження та скористатися наявною командою "сплячий".
Можливо, ви можете використати "на", щоб надіслати сигнал на ваш сценарій, який сидів, чекаючи цього сигналу.
Я насправді писав https://tamentis.com/projects/sleepuntil/ саме з цією метою. Це трохи перебільшує більшість коду походить від BSD 'at', тому він досить сумісний зі стандартами:
$ sleepuntil noon && sendmail something
Ось те, що я написав щойно для синхронізації декількох тестових клієнтів:
#!/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)
Цей сценарій працює до наступного "округленого" або "різкого" часу.
Простий варіант використання - це запуск ./sleep.py 10; ./test_client1.pyв одному терміналі та ./sleep.py 10; ./test_client2.pyв іншому.
untilвстановлено певну дату / час
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
Для цього я створив невелику утиліту під назвою Hypnos . Він налаштовується за допомогою синтаксису crontab і блокується до цього часу.
#!/bin/bash
while [ 1 ]; do
hypnos "0 * * * *"
echo "running some tasks..."
# ...
done
Щоб розширити основну відповідь, ось кілька валідних прикладів щодо маніпулювання рядком дати:
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
На OpenBSD можна використати наведені нижче дані для ущільнення */55-хвилинної crontab(5)роботи в 00погодинну (щоб переконатися, що генерується менше електронних листів, при цьому виконуючи одне і те ж завдання з точними інтервалами):
#!/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
Зверніть увагу, що це date(1)також порушить sleep(1)проект на кінцевій ітерації, оскільки 60хвилини не є допустимим часом (якщо це не так!), Тому нам не доведеться чекати зайвий час, перш ніж отримувати наш звіт електронною поштою.
Також зверніть увагу, що якщо одна з ітерацій займе більше 5 хвилин, відведених для неї, sleep вона також люб'язно зазнає невдачі за дизайном, не спавши взагалі (через те, що від'ємне число трактується як параметр командного рядка, замість того, щоб обертатися до наступну годину або навіть вічність), таким чином переконавшись, що ваша робота все одно може закінчитися протягом відведеної години (наприклад, якщо лише одна з ітерацій займає трохи більше 5 хвилин, то ми все одно мали б час наздогнати, без будь-що, що обгортається до наступної години).
Значення printf(1)потрібне, оскільки dateочікується рівно дві цифри для позначення хвилин.
Використовуйте смолистий. Це інструмент, який я написав, щоб спеціально це зробити.
https://github.com/metaphyze/tarry/
Це простий інструмент командного рядка для очікування до певного часу. Це не те саме, що "сон", який буде чекати деякий час. Це корисно, якщо ви хочете виконати щось у визначений час або, швидше за все, виконати кілька речей одночасно, наприклад, перевірити, чи може сервер обробляти кілька дуже одночасних запитів. Ви можете використовувати його таким чином із "&&" на Linux, Mac або Windows:
tarry -until=16:03:04 && someOtherCommand
Це зачекає до 16:03:04, а потім виконає someOtherCommand. Ось приклад Linux / Mac, як запускати кілька запитів, всі заплановані для запуску одночасно:
for request in 1 2 3 4 5 6 7 8 9 10
do
tarry -until=16:03:04 && date > results.$request &
done
Бінарні файли Ubuntu, Linux та Windows доступні за посиланнями на сторінці.