УПРАВЛЕНИЕ ВРЕМЕНЕМ
| at | выполнение задач в указанное время |
| b | порожденный shell фоновых задач |
| greet | своевременное приветствие с терминала |
| lastlog | сообщение времени последней регистрации |
| timelog | учет и статистика сеансов работы |
| today | печать календаря с отмеченной текущей датой |
ИМЯ: at
at - выполнить команду или файл в указанное время
НАЗНАЧЕНИЕ
Переводит любую командную строку в фоновый режим и выполняет ее в заданное время.
ФОРМАТ ВЫЗОВА
at hr:min cmd [;cmd ...]
ПРИМЕР ВЫЗОВА
at 12:00 echo "time for lunch!"
В двенадцать часов дня выводит сообщение на экран терминала.
ТЕКСТ ПРОГРАММЫ at
1 : 2 # @(#) tree v1.0 Execute command line at specific time Author: Russ Sage 2а Выполнить командную строку в указанное время 4 if [ $# -lt 2 ] 5 then echo "at: wrong arg count" >&2 6 echo "usage: at hr:min cmd [;cmd ...]" >&2 7 exit 1 8 fi 10 ITS=$1; shift 12 while : 13 do 14 TIME=`date | cut -c12-16` 16 if [ "$ITS" = "$TIME" ] 17 then eval $@ 18 exit 0 19 else sleep 35 20 fi 21 done &
ПЕРЕМЕННЫЕ СРЕДЫ ВЫПОЛНЕНИЯ
| ITS | Время, в которое следует выполнить указанные команды |
| TIME | Текущее время в системе |
Зачем нам нужен at?
На протяжении рабочего дня мы выполняем много небольших работ, которые нужно делать через различные интервалы времени. Некоторые вещи просто должны быть сделаны один раз в любое время, тогда как другие должны делаться в определенное время каждый день. Например, вам может понадобиться запускать процедуру копирования файлов каждую ночь, входить в другую систему раз в день и проверять почту или сообщения пользователей сети по заданной теме раз в несколько дней.
Командный файл at предоставляет механизм для выполнения задач, связанных со временем. Мы можем сказать системе, что и когда мы хотим сделать. Задача остается "спящей" в фоновом режиме до назначенного времени. Это дает нам возможность превратить компьютер в будильник, секретаря, администратора встреч и т.д.
Данная концепция не нова и уже существует в системе Berkeley UNIX под тем же именем. Она реализована также в последних версиях System V. Почему же тогда мы представляем здесь нашу собственную версию? Одна из причин в том, что многие из вас имеют более ранние версии UNIX, в которых это средство отсутствует. Но важнее, видимо, другое наша цель не в том, чтобы сделать существующие команды at устаревшими, а в показе того, как легко отслеживать время и реализовывать обработку, связанную со временем. Имея нашу собственную команду at, мы можем настроить ее по своему вкусу и изменить ее, когда необходимо. Команда at, представленная здесь, фактически более гибкая, чем at в системе Berkeley, хотя в первой отсутствуют некоторые особенности второй. Она более гибкая потому, что вы можете поместить настоящие команды в фоновую задачу at, в то время как для at в системе Berkeley вы должны использовать имя командного файла интерпретатора shell. Метод Berkeley запрещает вам вызывать исполняемые модули непосредственно в командной строке, а наша at - нет. (Конечно, вы можете с таким же успехом использовать командные файлы интерпретатора shell, если вам это необходимо.)
Что делает at?
Команда at дает нам возможность собирать несколько команд в одно целое и впоследствии запускать их. Когда они выполняются, их вывод может либо идти на экран, либо перенаправляться в определенный файл. Командная строка принимает два параметра: время выполнения и командную строку, которую следует выполнить. Время выражено в формате час:минута. Час должен быть указан строкой из двух цифр (в диапазоне от 0 до 23 часов), так как его использует команда date. Использование того же стандарта, что и в команде date, значительно упрощает команду at. В качестве второго параметра может быть любая команда, которую обычно можно ввести в командной строке интерпретатора shell. Можно также использовать конвейеры, составные команды и переназначения. Нет ограничений на то, какая команда может быть выполнена. Команда at может запустить обычный исполняемый модуль UNIX или ваш собственный командый файл.
Выход at по умолчанию направляется в стандартный вывод. Стандартным выводом в данном случае является экран терминала. Команда at в системе Berkeley не имеет вывода по умолчанию, что несколько затрудняет получение результата и отправку его на экран.
Команда at всегда запускается как фоновая задача. Нецелесообразно запускать ее в приоритетном режиме, где она блокирует терминал на все время своего выполнения. Пребывая в фоновом режиме, at освобождает ресурсы, но все же работает для вас. Между прочим, отметим, что когда процессы ставятся в фоновый режим изнутри командного файла, идентификатор процесса не печатается на экран, как это происходит, когда процессы запускаются в фоновом режиме с клавиатуры.
Порождение большого количества фоновых процессов может иметь отрицательный эффект для системы. Каждая фоновая задача - это цикл while интерпретатора shell, который работает очень медленно. Когда много фоновых процессов, мало времени центрального процессора остается на другие цели. В результате производительность системы ухудшается. В больших системах это, вероятно, не проблема, если только система не загружена множеством пользователей, но вы должны использовать это средство с осторожностью.
Отметим, что формат час:минута годится только для одного полного дня. Данная программа at задумана как ежедневная и не имеет средств запуска в определенный день или месяц, хотя вы можете легко расширить ее, как только поймете, как читается и используется информация о времени.
ПРИМЕРЫ
1. $ at 11:45 echo ^G^G It's almost lunch time
Без пятнадцати минут двенадцать дважды выдается звуковой сигнал (control-G) и выводится сообщение о ленче.
2. $ at 10:45 "if [ -s $MAIL ]; then echo ^G You have mail; fi"
Без пятнадцати одиннадцать проверяется, существует ли мой почтовый файл и есть ли в нем хотя бы один символ ($MAIL есть /usr/spool/mail/russ). Если это так, выдается звуковой сигнал и сообщение о том, что у меня есть почта.
3. $ at 17:00 "c; date; banner ' time to' ' go home'"
В пять часов вечера очищается экран (с помощью команды c, описанной далее в данной книге), печатается дата и выводится крупными буквами на весь экран сообщение "time to go home" ("пора домой"). С помощью апострофов в командной строке banner мы можем добиться вывода символа возврата каретки, чтобы разместить каждый набор слов в отдельной строке. Если какая-либо из этих команд не срабатывает (например, не найдена команда c), то и весь фоновый процесс оканчивается неудачей.
ПОЯСНЕНИЯ
Прежде всего at проверяет, правильно ли она была вызвана. Строки 4-8 делают проверку ошибок. В командной строке должны присутствовать по крайней мере два параметра: время и команда. Если это так, то счетчик позиционных параметров равен 2. Если этот счетчик меньше 2, произошла ошибка. В стандартный файл ошибок посылаются сообщения об ошибке с помощью переадресации в файловый дескриптор 2.
Переменная интерпретатора shell ITS инициализируется в строке 10. В ней устанавливается значение первого позиционного параметра ($1), которым является час:минута. Как только мы занесли это значение в переменную, оно больше не нужно нам в командной строке. Команда shift удаляет $1 из командной строки. Теперь командная строка состоит из вызывающей команды $0 (т.е. самой at) и остатка строки ($@ или $*). Вызывающая команда не вычисляется как часть остатка строки, поэтому вам не нужно заботиться об аргументе $0.
Далее at переходит к вечному циклу while в строках 12-21. Вечным этот цикл делает команда : (двоеточие). Это встроенная команда интерпретатора shell, которая ничего не делает кроме того, что всегда возвращает успешный статус выхода, заставляя тем самым цикл продолжаться. Команда true интерпретатора shell очень похожа и делает программу более наглядной. Мы же используем : вместо true, чтобы сократить издержки на порождение процесса для каждой итерации цикла. Команда : встроена в сам shell. True, напротив, является внешней командой в каталоге bin (так же, как ls), она должна быть найдена по файловому пути, выполниться и вернуть значение. Это занимает гораздо больше процессорного времени.
На каждой итерации цикла текущее время сверяется с назначенным временем, переданным из командной строки. Текущее время извлекается из команды date в строке 14. Обычно date выдает результат в таком формате:
| | Mon Mar 31 06:54:25 PST 1986 | |
Поскольку это строка фиксированного размера, мы можем посчитать номера позиций, в которых размещены час и минута. Данные час:минута находятся в позициях 12-16. Для получения этих символов мы запускаем команду date, пропускаем ее результат по конвейеру через cut и вырезаем нужные позиции. Весь результат присваивается переменной TIME. Заметим, что поле секунд не используется. Наименьшая единица времени в этой программе - минута.
Все волшебство данной команды заключено в строках 16-20. Если время, указанное в командной строке, равно текущему времени (строка 16), вычислить и выполнить остальные аргументы командной строки (строка 17), затем выйти с успешным нулевым значением (строка 18). Если время не совпало, немного поспать (строка 19) и повторить все сначала. Символ & в конце цикла в строке 21 превращает весь цикл while в фоновый процесс. Как мы можем убедиться, что shell выполняет все свои команды в фоновом режиме и никакие из них не выполняет в оперативном режиме? В действительности мы не можем этого сделать. Мы должны полагать, что shell так работает. Поскольку многое при программировании на shell делается исходя из опыта и интуиции, вам приходится испытывать многие вещи, чтобы увидеть, как они работают. Периодически shell преподносит сюрпризы и делает нечто совершенно неожиданное.
ИССЛЕДОВАНИЯ
Что бы случилось, если бы вы поставили задание at в фоновый режим, а затем вышли из системы? Ответ зависит от того, с каким shell вы работаете. Если у вас Bourne shell, то ввод команды control-D при выходе из системы прекращает выполнение всех ваших фоновых задач. Единственный способ оставить в живых фоновые задачи после выхода из системы - использовать команду nohup ("no hang up" - "не казнить").
Nohup обеспечивает, что все сигналы о прекращении процесса не достигают данного процесса. Не получая сигнал о прекращении выполнения, процесс думает, что вы все еще находитесь в системе. Синтаксис выглядит так:
nohup at 13:00 echo "back from lunch yet?"
Если вы запускаете Си-shell, все фоновые процессы продолжаются после вашего выхода из системы. Причина в том, что Си-shell переводит все свои фоновые задачи в состояние защиты от прекращения выполнения. Этот процесс автоматический, и его не нужно указывать явно.
Вы, возможно, удивлены тем, что в строке 17 использована команда "eval $@". Это сформировалось методом проб и ошибок. На начальных этапах разработки at команда "$@" использовалась сама по себе. При самостоятельном применении эта команда означает "выполнить все позиционные параметры". Поскольку это была единственная команда, выполнялась вся строка позиционных параметров, после чего возникали проблемы.
Использование переназначений и переменных интерпретатора shell сильно запутывало at.
Для иллюстрации рассмотрим пару примеров. Если мы запускаем at с командной строкой
at 09:30 echo $HOME
то все вроде бы работает. Сначала раскрывается переменная $HOME, затем echo печатает ее значение - /usr/russ. Но если мы запускаем командную строку
at 09:30 echo \$HOME
то переменная не раскрывается и echo фактически печатает $HOME вместо значения переменной $HOME. Мы избежали этого просто с помощью команды eval для повторного вычисления командной строки перед ее выполнением. Существо проблемы в том, что вызывающий интерпретатор shell не раскрывает значение переменной, поэтому мы заставляем выполняющийся shell повторно анализировать командную строку и вычислять все переменные. На этот раз значения переменных раскрываются, и мы получаем верный конечный результат.
МОДИФИКАЦИИ
Возможно, вы захотите более подробно рассмотреть интерфейс со временем. В нынешнем состоянии at воспринимает только время в пределах от 0 до 23 часов в течение одного дня. Неплохим дополнением было бы заставить его различать время суток, т.е. 8:30 a.m. (до полудня) или 8:30 p.m. (после полудня). Было бы неплохо также иметь возможность сказать "через 10 минут сделать то-то и то-то". В этом случае команда могла бы иметь примерно такой вид:
at -n 10 echo " do in now plus 10 minutes"
где -n было бы текущим временем, а 10 добавлялось бы к нему.
Другой очевидной областью модификации является наделение at возможностью запоминания периодов времени, превышающих сутки. Это может быть завтрашний день, определенный день или даже определенный месяц. Работа с определенным месяцем может быть не совсем реальной, поскольку командный файл, выполняемый в фоновом режиме в течение нескольких месяцев, потребует громадного количества процессорного времени, а также хранения постоянно возрастающего счетчика идентификаторов процессов, что даст, вероятно, пользователям искаженное представление об активности системы. По достижении максимального номера процесса, снова вернутся младшие номера, так что это не приведет к каким -либо серьезным последствиям. Решение вопроса о том, стоит ли такой ценой достигать вашей цели, зависит от того, считаете ли вы, что ваши требования излишне загружают систему.
ИМЯ: b
b Обработчик фоновых задач
ФОРМАТ ВЫЗОВА
b any_command_with_options_and_arguments (любая команда с опциями и аргументами)
ПРИМЕР ВЫЗОВА
b cg f.c
Компилировать исходный файл в фоновом режиме, где cg - командная строка компилятора, описанная в главе 10.
ТЕКСТ ПРОГРАММЫ b
1 : 2 # @(#) b v1.0 Background task handler Author: Russ Sage 2а Обработчик фоновых задач 4 ($@; echo "^G\ndone\n${PS1}\c") &
ОПИСАНИЕ
Зачем нам нужен b?
Как вы видели в последнем разделе, Bourne shell дает возможность запускать задачи в фоновом режиме выполнения. Это делает символ &. Что же на самом деле происходит, когда мы запускаем что-нибудь в фоновом режиме? Порождается еще один shell, который должен выполнить свою собственную командную строку. После того, как все его команды выполнятся, он завершается. Вы можете определить фоновые задачи по результату работы команды ps. Эти задачи выглядят как интерпретаторы shell, запущенные с вашего терминала, однако их владельцем, или родительским процессом в действительности является команда init, а не ваш регистрационный shell (это справедливо только для shell, к которым применена команда nohup). Интерпретаторы shell, к которым не применялась nohup, принадлежат вашему регистрационному shell. Ниже приводится пример распечатки команды ps для фоновых задач. Командой для выполнения в фоновом режиме была:
while :;do date; done &
Команда ps показывает мой регистрационный shell (PID=32), введенную мной командную строку для выполнения в фоновом режиме (PID=419) и shell, который выполняет цикл while (PID=449).
| | UID PID PPID C STIME TTY TIME COMMAND | | root 0 0 0 Dec 31 ? 0:03 swapper | root 1 0 0 Dec 31 ? 0:02 /etc/init | russ 32 1 0 14:18:36 03 1:26 -shV | russ 419 32 0 15:30:31 03 0:02 -shV | russ 449 419 2 15:30:31 03 0:02 -shV |
Ниже приведен листинг команды ps, который показывает фоновый shell, принадлежащий процессу init. Он был получен командой "b ps -ef", где b - утилита, которая будет рассмотрена далее. Как видите, последний процесс 471 есть фоновый shell, принадлежащий процессу 1, которым является init, а не мой регистрационный shell (PID=32).
| | UID PID PPID C STIME TTY TIME COMMAND | root 0 0 1 Dec 31 ? 0:04 swapper | root 1 0 0 Dec 31 ? 0:02 /etc/init | russ 32 1 1 14:18:36 03 1:30 -shV | russ 472 471 5 15:46:46 03 0:12 ps -ef | russ 471 1 0 15:46:46 03 0:00 -shV |
К чему все это приводит? Когда мы используем фоновые задачи, мы должны мириться с "неразборчивостью" при управлении асинхронными процессами. Каковы эти недостатки?
Во-первых, мы никогда не знаем момента завершения фоновых задач.
Единственный способ определить момент завершения таких задач - проверка результатов в каком-либо файле или некоторой работы, выполненной задачей, или использование команды ps и постоянное слежение за тем, когда процесс завершится. Такое слежение при помощи команды ps - не самый лучший способ, поскольку ps занимает много процессорного времени и очень медленно работает.
Второй неаккуратный момент - это символ приглашения после выдачи на ваш экран результата из фоновой задачи. После того как выдан результат из фоновой задачи, ваш регистрационный shell ожидает ввода команды, но приглашения может и не быть, поскольку оно было удалено с экрана некоторым другим сообщением. Вы можете ожидать приглашения целый день, но оно никогда не появится, поскольку оно уже было выведено на экран. Вы просто должны знать, что shell ждет вашу команду.
Нам необходимо инструментальное средство, которое сообщает нам о завершении фоновой задачи, а также восстанавливает наш экран после выдачи на него каких-либо результатов. Можем ли мы сказать, выполняла ли вывод на экран фоновая задача или нет? Нет, поэтому мы должны жестко запрограммировать восстановление экрана в программе.
Что делает b?
Командный файл b - это механизм, который помогает в выполнении фоновых задач. Он запускает наши фоновые задачи. По завершении он отображает на экран слово "done" и затем повторно выводит символ-приглашение shell.
Данное средство не имеет опций и проверки на наличие ошибок. Обработчик фоновых задач фактически выполняет командную строку, которую мы ему передаем, и последующую обработку. Отметим, что для выдачи на экран вашего символа приглашения, вы должны экспортировать переменную PS1 из вашей текущей среды. Это может соблюдаться не на всех машинах, поскольку каждая система UNIX имеет свои особенности. В системе XENIX переменная PS1 не передается, возможно из-за того, что это shell, который вызывает другой shell в фоновом режиме. Если вы скажете "sh" в интерактивном режиме, он будет передан как приглашение. Система UNIX так прекрасна и удивительна!
ПРИМЕРЫ
1. $ b ls -R ..
Начиная с родительского каталога, рекурсивно составляется список всех файлов и выводится на экран. Обратите внимание, что при использовании фоновых задач вы не можете эффективно передать все это по конвейеру команде more, поскольку обычным входным устройством для фоновых задач является /dev/null. Команда more не работает нормально, когда ее вызывают из фонового режима. Это также имеет смысл, поскольку вы могли бы иметь две задачи - одну в фоновом режиме, а другую в приоритетном производящие беспорядок на экране. Фоновая команда more должна была бы сохранять в неприкосновенности то, что выводит на экран приоритетная команда.
2. $ b echo hello > z
Файл z содержит не только слово "hello", но также и сообщение "done", поскольку переадресация в файл z выполняется во внешнем shell. Переадресация для подзадачи должна быть выполнена в круглых скобках программы b, а мы в данном случае не можем этого сделать.
3. $ b sleep 5; echo hello
Эта командная строка не может быть выполнена, поскольку программа b воспринимает только команду sleep. Команда echo не помещается в фоновый процесс и сразу же выполняется.
4. $ b "sleep 5; echo hello"
Эту командную строку мы тоже не можем выполнить, поскольку эти две команды будут восприняты командным файлом b как одна. Затем команда sleep не выполнится, поскольку "5; echo hello" является недопустимым указанием временного периода для команды sleep.
ПОЯСНЕНИЯ
Обратите внимание, что в строке 4 вся структура команды заключена в круглые скобки, за которыми следует символ &. Круглые скобки передают всю структуру подчиненному shell, который затем помещается в фоновый режим выполнения. Помещая все команды в один shell, мы гарантируем вывод на экран слова "done" после завершения последнего процесса.
Данная командная строка выполняется с помощью символов $@. Это означает: "выполнить всю командную строку, расположенную справа". Поскольку выражение $@ выполняет само себя (т.е. не в операторе echo или в чем-либо подобном), то shell просто выполняет команды исходной командной строки. Это именно то, что мы хотим! Обратите внимание, что здесь нет никакого оператора eval. Поскольку то, что мы делаем, похоже на своего рода "командный интерпретатор строк" для их ввода и исполнения, вы могли бы подумать, что команда eval здесь необходима. По опыту мы знаем, что это не так. Похоже, что применение eval усложнит дело.
Даже наш старый тест, использующий переменные среды выполнения, работает. По команде
b echo $HOME
на экран будет выдано сообщение
/usr/russ
Когда вся команда выполнится, подается звуковой сигнал и выводится сообщение, информирующее пользователя о том, что операция завершилась. Поскольку это сообщение накладывается на то, что было на экране, то переотображается начальный символ приглашения (PS1). Это делает нормальным вид экрана в том смысле, что символ приглашения shell сообщает об ожидании ввода.
ИМЯ: greet
greet Своевременное приветствие с терминала
НАЗНАЧЕНИЕ
Определение времени суток и печать приветствия и какого-либо сообщения на терминал в зависимости от времени дня.
ФОРМАТ ВЫЗОВА
greet
ПРИМЕР ВЫЗОВА
greet Вызывает командный файл greet, который определяет время и печатает соответствующее сообщение.
ТЕКСТ ПРОГРАММЫ greet
1 : 2 # @(#) greet v1.0 Timely greeting from the terminal Author: Russ Sage 2а Своевременное приветствие с терминала 4 if [ `expr \`date +%H\` \< 12` = "1" ] 5 then echo "\nGood morning.\nWhat is the best use of your time right now?" 6 elif [ `expr \`date +%H\` \< 18` ="1" ] 7 then echo "\nGood afternoon.\nRemember, only handle a piece of paper once!" 8 else echo "\nGood evening.\nPlan for tomorrow today." 9 fi
ОПИСАНИЕ
Зачем нам нужен greet?
Одним из замечательных преимуществ многопользовательских операционных систем является то, что они имеют хорошо развитую концепцию времени. Обычно они содержат часы реального времени и некоторое программное обеспечение, которое манипулирует с ними. Однако всегда есть место для дополнительного программного обеспечения, работающего со временем. Такие средства могут быть написаны как на языке Си, так и на shell-языке.
Как мы извлекаем и выделяем время с помощью командного файла интерпретатора shell? Доступно много способов, но стандартная команда UNIX date, видимо, является наилучшим способом. В случае языка Си вы должны программно управлять преобразованием времени и временными зонами. Команда date делает это для вас.
Важна также единица времени. Должны ли мы различать секунды, минуты, часы, дни или недели? Это все зависит от требуемого приложения. В нашем простом примере мы различаем только три части суток: утро, день и вечер. Мы определили эти периоды так: с полуночи до полудня, от полудня до шести часов и от шести часов до полуночи соответственно.
Что делает greet?
Greet - это утилита, которая приветствует пользователя различными сообщениями в зависимости от времени суток. Выводимые сообщения не так важны. Они в основном использованы как примеры, показывающие, как могут быть выполнены какие-то команды. Если вы работаете в одиночестве и хотели бы поболтать, эти сообщения могли бы читаться периодически из соответствующих файлов для создания иллюзии автоматической письменной болтовни в зависимости от времени суток.
Действительной же целью является создание каркаса программы, которая может переключаться в зависимости от параметров времени. Путем расширения концепции времени вы можете создать другие утилиты, которые знают, когда им работать (в какой промежуток времени) и могут вести себя иначе в соответствии со временем.
Greet не требует ничего в командной строке. Не выполняется никакой проверки на наличие ошибок, поэтому и нет в программе синтаксической подсказки. Выход команды greet может быть переадресован в файл или передан по конвейеру другому процессу.
ПРИМЕРЫ
1. $ if greet | fgrep 'morn' > /dev/null > then morning_routine > fi
Выполняется greet. Стандартный вывод greet по конвейеру передается на стандартный ввод fgrep. Производится поиск символьной строки "morn". Весь выход переадресовывается в никуда, так что он не засоряет экран. Если выходной статус команды fgrep равен нулю (она нашла нужную строку), выполняется файл morning_routine.
2. $ at 10:30 greet; at 13:50 greet
Вы могли бы вставить это в ваш .profile. Два процесса at будут выполняться на вашей машине в фоновом режиме до тех пор, пока не наступит время их запуска - тогда они поприветствуют вас на вашем терминале. Правда, это может причинить небольшое неудобство. Сообщение может появиться, когда вы работаете в редакторе, и нарушить содержимое экрана, но на самом деле оно не изменит ваш редактируемый файл.
ПОЯСНЕНИЯ
Вся программа представляет собой один большой оператор if -then-else в строках 4-9. Логика программы выглядит на псевдокоде следующим образом:
if it is morning если утро then echo morning statement то вывести "утреннее" приветствие else if it is noon иначе если день then echo noon statement то вывести "дневное" приветствие else echo evening statement иначе вывести "вечернее" приветствие
В действительности программа гораздо сложнее, поэтому переведем дыхание и приступим к делу.
В строке 4 проверяется текущее время на то, меньше ли оно 12 часов. Если да, то фраза команды expr выводит на стандартное устройство вывода единицу ("1"). Поскольку символы ударения (`), которые обрамляют эту фразу, перехватывают стандартный вывод, символ 1 становится частью оператора проверки, что указано квадратными скобками ([]). Затем оператор test проверяет, равен ли выход команды expr литеральной единице. Если они одинаковы, то в строке 5 выводится "утреннее" сообщение.
Рассмотрим более подробно, как раскрывается оператор expr. Во-первых, он заключен в символы ударения. Это означает, что он выполняется перед оператором проверки. Затем его выход помещается для обработки в оператор test. Однако внутри оператора expr имеется еще одно выражение между знаками ударения, которое выполняется до оператора expr. Такое старшинство выполнения управляется интерпретатором кода внутри shell.
Внутренние знаки ударения сохраняются при начальном синтаксическом разборе строки, поскольку они экранированы символами обратной косой черты. Первой запускается команда date, имеющая в качестве выхода только текущее значение часа в соответствии с форматом %H. Затем expr использует данное значение часа для проверки, меньше ли оно 12.
Если да, expr печатает единицу. Если значение часа больше или равно 12, то возвращаемое значение равно 0. Такое понимание, что 1=истина и 0=ложь, соответствует синтаксису, используемому в языке Си.
Однако ранее мы замечали, что в среде программирования на языке shell 1 означает ложь, а 0 - истину. Это происходит потому, что проверяемое значение оператора if является в действительности статусом выхода из предварительно выполненной команды. Нуль соответствует нормальному завершению, поэтому 0 использован для переключения проверки в состояние "истина" и выполнения оператора then. Для того, чтобы преобразовать возвращаемый статус 1 (при условии, что значение часа меньше 12) в нуль (для переключения оператора then), мы используем команду test. Возвращаемый статус единицы равен константе 1, поэтому команда test возвращает 0, что представляет истину. Вот так!
Если бы не были использованы вложенные знаки ударения, то единственным способом передачи данного типа информации другому процессу было бы применение переменных shell. Использование вложенной командной подстановки дает нам большую гибкость и простоту программирования. Чем больше глубина вложенности, тем глубже экранирование знаков ударения. Порядок экранирования символами обратной косой черты такой: не нужно для внешней команды, один раз для второй внутренней команды, пять раз для третьей внутренней команды. На четвертом уровне их должно быть семь или девять (я еще не пробовал), но вероятно нет большой нужды во вложенности такой глубины.
Если проверка в строке 4 дает "ложь", выполняется строка 6. Это оператор else от первого if и одновременно следующий if. В таких особых случаях синтаксис shell меняется. Ключевое слово "else" становится ключевым словом "elif".
Второй if использует команду test точно так же, как и первый. Проверяемое время здесь 18, что представляет собой 6 часов вечера. Если вторая проверка также дает "ложь", выполняется последний оператор в строке 8. Этот else не использует команду test, поскольку после выполнения первых двух проверок мы можем сделать вывод, что остался последний период времени, а именно период после 18:00.
ИМЯ: lastlog
lastlog Сообщает время последней регистрации
НАЗНАЧЕНИЕ
Записывает и выводит на экран день и время вашей последней регистрации в системе.
ФОРМАТ ВЫЗОВА
lastlog [-l]
ПРИМЕР ВЫЗОВА
lastlog Печатает дату, когда вы последний раз регистрировались
ТЕКСТ ПРОГРАММЫ lastlog
1 : 2 # @(#) lastlog v1.0 Report last login time Author: Russ Sage 2а Сообщает время последней регистрации 4 if [ $# -gt 1 ] 5 then echo "lastlog: arg error" >&2 6 echo "usage: lastlog [-l]" >&2 7 exit 1 8 fi 10 if [ "$#" -eq "1" ] 11 then if [ "$1" = "-l" ] 12 then date >> $HOME/.lastlog 13 lastlog 14 else echo "lastlog: unrecognized option $1" >&2 15 echo "usage: lastlog [-l]" >&2 16 exit 1 17 fi 18 else echo "Time of last login : `tail -2 $HOME/.lastlog | 19 (read FIRST; echo $FIRST)`" 20 fi
ПЕРЕМЕННЫЕ СРЕДЫ ВЫПОЛНЕНИЯ
| FIRST | Хранит первую из двух введенных строк |
| HOME | Хранит имя вашего регистрационного каталога |
Зачем нам нужен lastlog?
Одним из преимуществ работы в системе UNIX является то, что в ней совершается автоматическая запись вашего начального времени при каждом сеансе работы - вашего времени регистрации. Эта информация может быть полезной по нескольким причинам. Вопервых, вы можете запомнить, когда вы действительно работали в системе последний раз и проверять, не регистрировался ли кто-нибудь под вашим паролем во время вашего отсутствия. Как мы увидим в главе 9, имеется ряд возможностей для того, чтобы кто-нибудь мог "заимствовать" ваш пароль без спроса. По этой причине многие коммерческие системы сообщают вам, когда вы регистрировались последний раз (или когда, по их мнению, вы это делали).
Другой возможной причиной мог бы быть подсчет общего времени в конце сеанса работы. Вы могли бы использовать это как учетную информацию для себя или вычислительного центра. Немного позже мы представим средство, которое помогает при таких подсчетах.
Разрабатываемое нами инструментальное средство должно иметь возможность записывать новые значения времени и выводить на экран время нашей последней регистрации. Важно, что данная программа может быть вызвана так, что она не изменяет файл с данными, но постоянно выводит время последней регистрации.
Что делает lastlog?
Lastlog - это программа, которая записывает время вашей регистрации при каждом входе в систему. Затем это время хранится в файле данных в вашем регистрационном каталоге под именем $HOME/.lastlog. Имя файла lastlog начинается с точки с той целью, чтобы сделать его невидимым для команды ls. Укрытие "служебных" файлов от распечатки по умолчанию несколько предохраняет от любопытных глаз, а также убирает эти файлы с дороги, когда вы просматриваете что-то другое.
При вызове без опций lastlog печатает для нас дату последней регистрации, получая запись из файла .lastlog.
Для выполнения новой записи в файл .lastlog необходимо вызвать lastlog с опцией -l. При этом новое значение времени запишется в файл .lastlog, а затем командный файл lastlog вызовет сам себя для вывода на экран нового значения - небольшая рекурсия.
Для того, чтобы программа lastlog работала автоматически, вы должны выполнять ее из вашего файла .profile во время регистрации. При таком способе она запишет последнее время в файл .lastlog. В качестве примера посмотрите файл .profile в первой главе.
ПОЯСНЕНИЯ
В строках 4- 8 выполняется проверка на наличие ошибок. Если вы вызвали lastlog с числом аргументов больше одного, то это приведет к ошибке. Выводится сообщение на стандартное устройство регистрации ошибок, и lastlog завершается со статусом ошибки 1.
Строки 10-20 представляют собой оператор if-then-else, который показывает, был ли это вызов для записи нового значения времени или для печати старых значений.
Если в строке 10 число позиционных параметров равно одному, то мы знаем, что либо этот параметр должен быть опцией -l, либо это ошибка. Следующий оператор if в строке 11 проверяет, является ли первый позиционный параметр опцией -l. Если да, то в файл $HOME/.lastlog добавляется текущая дата и lastlog вызывается снова без аргументов для печати предыдущей даты регистрации. (Мы только что видели, как это делается.) Если это не был аргумент -l, то строки 14-16 выполняют обработку ошибки.
Если число позиционных параметров равно нулю, выполняется оператор else в строке 18. Отсутствие опций означает, что мы хотим найти время нашей последней регистрации на машине и распечатать его. Это кажется довольно простым, но кто сказал, что машины просты?
Если вы помните последовательность работы, то мы сперва регистрируем новое время, а затем хотим найти время нашей предыдущей регистрации. Для файла .lastlog это означает, что наше текущее время регистрации находится в самом конце файла, а наше предыдущее время регистрации находится в строке непосредственно перед ним. Это значит, что мы должны получить вторую строку от конца файла. Да уж.
Как видно из строки 18, она занимается получением последних двух строк. Команда tail красиво выполняет эту работу. Нам нужен такой способ, чтобы мы могли прочитать именно первую строку, а вторую отбросить, что выполняется в строке 19. Мы передаем по конвейеру выход команды tail подчиненному shell (указанному круглыми скобками), который читает первую строку и затем отображает ее. А что же со второй строкой? Она никогда не берется и пропадает. Другим способом может быть передача выхода команды tail по конвейеру команде "head -1". Поскольку эта команда не имеет других опций, мы не даем никаких примеров. Тем не менее, давайте теперь рассмотрим наше другое средство регистрации времени входа в систему.
