Expect и kibitz

Оригинал http://www.ibm.com/developerworks/ru/library/l-expect_1/index.html http://www.ibm.com/developerworks/ru/library/l-expect_2/index.html http://www.ibm.com/developerworks/ru/library/l-expect_3/index.html

Что умеет делать Expect

Инструментальное средство Expect предназначено в первую очередь для управления интерактивными программами, которые выводят приглашение и ожидают от пользователя ввода ответа с клавиатуры, например, passwd, ftp, telnet, rlogin, su и многие другие. В обычных shell-скриптах такие программы требуют обязательного присутствия человека, вводящего ответы на их запросы. Expect же позволяет автоматизировать диалоговый режим с помощью несложных скриптов на базе языка Tcl, а кроме того, обеспечивает пошаговое управление подпроцессами: можно проверять результат каждой операции, и по результату проверки определять, какие входные данные необходимо предоставить.

Автором программы является Дон Лайбис [Don Libes] из Национального института стандартов и технологий (National Institute of Standards and Technology; NIST). Он не случайно взял за основу Tcl (Tool Command Language – инструментальный командный язык, разработчик Джон Остерхаут [John Ousterhout]), поскольку сам по себе Tcl – это функционально полный язык скриптов, синтаксически простой и удобный в использовании. В нём есть команды создания переменных (set), обработки строк, математические операции, управляющие конструкции (if, while, foreach и т.п.), возможность выполнять внешние программы (команды Unix). Большинство команд задаётся так же, как в оболочке shell, т.е. команда и её аргументы просто разделяются пробелами. Фигурные скобки объединяют элементы в блоки и позволяют записывать инструкции на нескольких строках. В качестве разделителя команд используется точка с запятой; в конце строки и перед закрывающей фигурной скобкой разделитель не обязателен.

Как работает Expect

Expect запускается в режиме командной строки (в консоли или в эмуляторе терминала в среде X) в соответствии со следующим форматом:

expect [-dDinNv] [-c <список_команд>] [ [-[f|b]] <файл_скрипта>] [<аргументы>]

Флаг -d активизирует вывод некоторой диагностической информации, в основном касающейся выполнения внутренних операций команд, таких как expect и interact.

Флаг -D активизирует интерактивный отладчик. Более подробно о работе отладчика можно узнать из документации.

Флаг -i переводит Expect в интерактивный режим, в котором ожидается ввод команд с клавиатуры, а не из файла скрипта.

Флаги -n и -N отключают использование файлов ресурсов. Если существует файл $exp_library/expect.rc, то данные из него считываются автоматически при условии, что не задан флаг -N. Сразу после этого автоматически считываются данные из файла ~/.expect.rc при условии, что не задан флаг -n.

Флаг -c предваряет команду или список команд, которые должны быть выполнены до того, как начнётся выполнение команд скрипта. В списке команды отделяются друг от друга точкой с запятой. Команду или список команд необходимо записывать в кавычках, чтобы защитить их от воздействия командной оболочки.

После флага -f записывается имя файла скрипта, из которого будут считываться команды.

По умолчанию весь файл скрипта считывается в память перед выполнением. Но иногда необходимо, чтобы выполнялось построчное чтение, например, для работы с устройством стандартного ввода. Чтобы установить такой режим считывания, воспользуйтесь флагом -b.

Из форматной записи очевидно, что флаги -f и -b являются взаимоисключающими и не обязательными. Иными словами, если встречается только символ "-", то Expect будет считывать команды из стандартного устройства ввода stdin (как правило, это клавиатура).

Флаг -v выводит номер текущей версии и завершает работу программы.

В конце строки могут быть записаны аргументы, передаваемые в скрипт. Эти аргументы сохраняются в форме списка в переменной argv. Переменная argc инициализируется числовым значением, соответствующим длине списка argv.

Как и для любого скриптового языка в Unix-системах, если в первой строке файла, содержащего команды Expect, записать строку идентификации:

#!/usr/bin/expect -f

и установить для него статус "выполняемый" в наборе прав доступа, то можно запускать непосредственно этот файл как обычную программу. Разумеется, здесь необходимо указать полный путь к файлу expect в вашей системе.

Набор команд, используемых в Expect

Вообще говоря, для написания Expect-скриптов не требуется глубокое знание языка Tcl, поскольку в самой Expect реализованы дополнительные команды-расширения, обеспечивающие почти всю функциональность. Вот основные, наиболее часто используемые команды:

spawn – запуск подпроцесса (в одном скрипте можно запустить несколько подпроцессов для взаимодействия с несколькими внешними программами).

send – отправка входных данных в подпроцесс.

expect – получение выходных данных из подпроцесса и выполнение соответствующего действия. Эта команда записывается в следующем формате:expect "шаблон" {инструкция ... }

Если "шаблон" встречается в строке выходных данных, то выполняется соответствующая инструкция.

interact – эта команда позволяет выполнить часть задач в "автоматическом режиме", а затем передать управление пользователю. В свою очередь, пользователь может в любой момент вернуть управление скрипту.

Чтобы лучше понять, как применяются эти команды на практике, рассмотрим простой пример. Приведённый ниже скрипт пересылает файл /etc/passwd с одного компьютера на другой, используя программу ftp.

spawn /usr/bin/ftp <сетевое_имя|IP-адрес передающего компьютера>
while 1 { expect {
"Name*: " {send "<регистрационное_имя_клиента>\r"}
"Password:" {send "<пароль>\r"}
"ftp> " {break}
"failed" {send_user "Нет доступа к FTP-серверу.\r"; exit 1}
timeout {send_user "Время ожидания ответа истекло."\r"; exit 2}
}}
send "lcd /etc\r"
expect "ftp> " {send "cd pub/sysfiles\r"}
expect "ftp> " {send "get passwd\r"}
expect "ftp> " {send "quit\r"; send_user "\r"}
exit 0

Данный скрипт запускается на принимающем компьютере. В первой строке инициализируется подпроцесс интерактивного ftp-клиента c указанием сетевого имени или IP-адреса компьютера, выполняющего роль сервера, – с него будет передаваться требуемый файл.

Цикл while языка Tcl позволяет организовать регистрацию клиента на ftp-сервере, которая в обычных условиях представляет собой диалоговую процедуру. Здесь же expect ожидает ответ сервера, сравнивает его с заданными шаблонами и, если один из этих шаблонов найден в строке ответа сервера, то выполняет соответствующую команду или команды. Обычно сервер начинает процедуру регистрации с запроса имени (первый шаблон в блоке expect – в ответ отсылается имя ftp-клиента) и пароля (второй шаблон). Если имя и пароль указаны правильно, то процедура регистрации считается успешно завершённой, и сервер выдаёт приглашение "ftp> " (третий шаблон). В этом случае происходит выход из цикла (команда break). Последние два шаблона соответствуют исключительным ситуациям. По тем или иным причинам сервер может запретить регистрацию клиента с заданным именем и паролем и выдать сообщение "Login failed". При обнаружении шаблона "failed" в строке ответа сервера пользователю-клиенту выдаётся сообщение о недоступности сервера (ещё одна внутренняя команда программы Expect – send_user – строка не передаётся в подпроцесс, как в команде send, а записывается в стандартный поток вывода), после чего скрипт завершает своё выполнение с кодом ошибки (exit 1). Ключевое слово timeout позволяет реагировать на ситуации, когда в течение 10 секунд ничего не происходит (десятисекундный тайм-аут принят по умолчанию в программе Expect; вы можете изменить это значение, например, "set timeout 30"). В нашем случае выводится сообщение об истечении времени ожидания, и скрипт завершается с кодом ошибки exit 2.

Далее записана последовательность команд, отправляемых ftp-серверу. Здесь необходимо отметить, что каждая команда expect ожидает завершения выполнения предыдущей команды (выдачи приглашения "ftp> "). После того как файл passwd скопирован, закрывается сеанс работы с ftp-сервером (посылается команда "quit"), и скрипт заканчивает свою работу с кодом успешного выполнения (exit 0).

Несколько замечаний по использованию Expect

Прежде чем начать исследование административных скриптов, необходимо обратить внимание на некоторые вопросы, возникающие при использовании Expect в реальной работе.

Одна из самых существенных проблем: сама по себе программа Expect не обладает способностью распознавать промпты (строки приглашения) различных командных оболочек, а необходимость в этом возникает достаточно часто. Решить эту задачу помогает составление регулярного выражения, описывающего конечную часть строки промпта (именно конечную, потому что настройки всей строки приглашения отличаются большим разнообразием), и сохранение этого выражения в переменной. Можно использовать следующий фрагмент кода:

set prompt "(%|#|\\$) $";
catch {set prompt $env(EXPECT_PROMPT)}
...
expect -re $prompt

В первой строке переменной prompt присваивается регулярное выражение. Следует отметить, что для записи регулярных выражений применяется их диалект в языке Tcl. В скобках сгруппированы альтернативные варианты промпт-символов: % – для оболочек Cshell, # – для режима суперпользователя root, $ – для прочих оболочек. Символ "доллар" приходится экранировать, так как в регулярных выражениях он обозначает конец строки. Кроме того, необходимо защитить и сам символ "обратный слэш" от интерпретации его командной оболочкой. Далее следует символ "пробел", за ним признак конца строки ($).

Во второй строке выполняется встроенная команда Tcl catch, которая позволяет выполнить заданный код и вернуть управление в вызывающий скрипт даже при возникновении ошибки. В какой-то мере это аналог перехвата исключений в таких языках, как C++, C#, Java. Внутри блока catch выполняется присваивание переменной prompt значения из массива переменных среды env с индексом EXPECT_PROMPT. Иными словами, даже если переменной среды EXPECT_PROMPT не существует или она не содержит значения, выполнение скрипта не будет прервано, а переменная prompt сохранит значение, присвоенное ей в первой строке.

После этого в любой части скрипта, где ожидается приглашение командной оболочки, можно использовать инструкцию expect -re $prompt, в которой ключ -re предупреждает о том, что значение переменной prompt следует интерпретировать как регулярное выражение, а не как обычную строку.

Ещё одна особенность – все переменные, задействованные в командах Expect, по умолчанию являются локальными, если для них не указан явно модификатор global. Следствием этого является проблема, возникающая в случае выполнения команды spawn внутри процедуры. После выхода из такой процедуры идентификатор порождённого процесса spawn_id становится "невидимым" (область его видимости ограничена телом процедуры), следовательно, невозможно получить доступ и к самому процессу. В подобных ситуациях перед вызовом spawn необходимо вставить команду global spawn_id.

Примеры административных скриптов

Достаточно часто перед администратором встаёт задача создания большой группы новых пользователей. Вводить данные вручную, чередуя команды useradd и passwd, – весьма утомительное занятие. Конечно, у каждого опытного администратора есть своё "секретное оружие" – мне доводилось видеть хитроумные скрипты, которые в той или иной мере автоматизируют процесс создания учётных записей. Но знание Expect позволяет администратору решить ту же задачу с меньшими трудозатратами. Ниже приведён пример, в котором имена и пароли вновь создаваемых учётных записей пользователей считываются из заранее подготовленного текстового файла. Разумеется, такой файл с конфиденциальной информацией должен храниться в защищённом месте, но в данном примере для простоты предположим, что файл находится в текущем рабочем каталоге и имеет следующий вид.

Содержимое текстового файла newusers:anna gp63r2d4
boris iyb1z9sd
victor fm571jq0
...
sergei e2h5mw7z
tatyana pv92x3au

А сам скрипт выглядит так:

#!/usr/bin/expect
set ufile [open "./newusers" r]
foreach uline [split [read $ufile] "\n"] {
set username [lindex $uline 0]
set password [lindex $uline 1]
if { [string length $username] > 0 } {
spawn "/bin/bash"
send "useradd $username\r"
expect -re "# $"
sleep 1
log_user 0
send "passwd $username\r"
expect "Новый пароль UNIX : "
send "$password"
expect "Повторите ввод нового пароля UNIX : "
send "$password"
expect " успешно обновлены."
log_user 1
puts stdout "Пользователь $username создан.\r"
}
}
close $ufile

Начинается скрипт с процедуры открытия файла, содержащего имена и пароли пользователей, в режиме "только для чтения". Дескриптор открываемого файла присваивается переменной ufile.

Во второй строке инициализируется цикл перебора элементов списка foreach с переменной цикла uline. Поскольку файл считывается в виде непрерывного потока символов, мы воспользуемся командой языка Tcl для разделения этого потока символов на элементы списка с помощью символа-разделителя "\n" (переход на новую строку). Таким образом, каждая строка файла newusers становится элементом списка и поочерёдно, в порядке считывания, передаётся в переменную uline, что является обязательным требованием конструкции foreach.

С точки зрения языка Tcl (следовательно, и с точки зрения Expect) содержимое переменной uline также является списком, т.е. в паре "имя_пользователя пароль" имя является элементом списка uline с индексом 0, а пароль – элементом с индексом 1. Этим мы воспользуемся, чтобы создать ещё две переменные – username и password, извлекая значения для них по соответствующему индексу (Tcl-команда lindex).

Проверка длины имени пользователя необходима потому, что если в конце файла newusers случайно окажется пустая строка, то последним в перебираемом списке будет пустой элемент, который следует исключить из обработки.

Для каждого элемента, успешно прошедшего проверку, порождается процесс /bin/bash (если у вас не установлена эта командная оболочка, то внесите необходимые изменения). В этот процесс посылается команда добавления нового пользователя с указанием текущего имени, содержащегося в переменной username. Мы должны дождаться появления символа приглашения командной оболочки. Команда "sleep 1" приостанавливает выполнение на 1 секунду. Это не обязательно, но на современных сверхбыстрых компьютерах с многоядерными процессорами позволяет избежать некоторых "неожиданностей".

Команда "log_user 0" отключает вывод протокола диалога send-expect на экран. Далее следует диалог ввода и подтверждения пароля для только что созданного пользователя, после чего вывод диалоговых сообщений снова включается (log_user 1) и выводится сообщение об успешном создании учётной записи пользователя.

Когда все записи из файла newusers считаны и обработаны, происходит выход из цикла foreach. Остаётся лишь закрыть файл и завершить выполнение скрипта.

Данный скрипт можно поместить в crontab и запланировать его выполнение во время минимальной загрузки системы (например, в ночное время), когда массовое создание новых пользователей никому не будет мешать.

Чтобы не утруждать себя сочинением десятков уникальных паролей, можно воспользоваться скриптом mkpasswd, входящим в стандартный комплект установки пакета Expect. Этот скрипт позволяет регулировать длину генерируемого пароля, количество цифровых символов, букв верхнего и нижнего регистра, специальных символов. Но в этом случае сгенерированные и назначенные пароли нужно каким-либо образом сохранять, чтобы потом сообщить их пользователям. Кстати, mkpasswd умеет также присваивать созданный пароль существующему пользователю.

Вместе с программой Expect устанавливаются и другие скрипты. Например, passmass выполняет смену пароля на нескольких сетевых компьютерах одновременно. Скрипт dislocate позволяет отключать процессы от терминала и вновь подключать их, а unbuffer запрещает буферизацию вывода. Чрезвычайно интересен скрипт kibitz, обеспечивающий взаимодействие двух (и более) пользователей с одной командной оболочкой. Для каждого из этих и прочих "штатных" скриптов имеется man-страница, а кроме того, вы можете изучать исходные коды самих скриптов, что является наилучшим способом освоения Expect по мнению самого Дона Либиса (исправляю неточность в написании его фамилии в первой статье цикла).

3.Практическое применение Expect в сетевом администрировании

1. Введение

Сразу отмечу, что приведенные в статье примеры скриптов представляют собой предельно упрощённые решения задач сетевого администрирования. Это сделано преднамеренно – для удобства восприятия читателями. После того как вы освоите синтаксис и семантику команд, усовершенствовать эти скрипты можно будет самостоятельно.

2. Выполнение команды настройки на удалённом компьютере

Достаточно часто в локальной сети возникает необходимость выполнения команды настройки среды на какой-либо рабочей станции. Рассмотрим такую ситуацию: на одном из компьютеров периодически требуется синхронизация даты и времени из-за неполадок аппаратного таймера.

Эту проблему поможет решить следующий скрипт. Предположим, что с датой и временем некорректно обращается компьютер по имени comp052.01:

#!/usr/bin/expect
02: spawn ssh <имя_пользователя>@comp052
03: expect "password:"
04: send "<пароль_пользователя>\r"
05: expect -re "\\$ $"
06: send "su\r"
07: expect "(Password:|Пароль:)"
08: send "<пароль_root>\r"
09: expect -re "# $"
10: exec date > /tmp/datesync.tmp
11: exec cat /tmp/datesync.tmp
12: set newtime [exec cat /tmp/datesync.tmp]
13: send "date -s \"$newtime\"\r"
14: expect -re "# $"
15: send "exit\r"
16: expect -re "\\$ $"
17: send "logout\r"
18: expect "closed."

19: exit 0

Со всеми командами вы уже знакомы по примерам в предыдущих статьях цикла. Отмечу лишь, что двухступенчатая процедура регистрации в качестве обычного пользователя и последующего перехода в ранг суперпользователя обусловлена требованиями безопасности при работе через ssh. Практически во всех системах соблюдается рекомендация: запретить непосредственный вход суперпользователя root по протоколу SSH.

Команда вывода содержимого файла /tmp/datesync.tmp (строка 11) на локальную консоль позволяет зафиксировать в системном журнале время выполнения данного скрипта.

Подразумевается, что вместо условных "шаблонов" <имя_пользователя>, <пароль_пользователя> <пароль_root> подставляются реально существующие на обслуживаемом компьютере (в данном примере – comp52) имя, пароль и пароль суперпользователя соответственно.

Описанный выше скрипт можно поместить в системную таблицу crontab и запланировать его выполнение с требуемой периодичностью.

3. Автоматизация выполнения команды rsync на удалённом компьютере

Ещё одна задача сетевого администрирования – резервное копирование определённых данных и параметров настройки на сетевых компьютерах. В небольшой сети для администратора не составит труда выполнить несколько команд rsync вручную. А если сеть состоит из нескольких десятков или даже сотен машин? Снова зовём на помощь Expect.

В следующем примере команда rsync использует протокол SSH – безопасность превыше всего.

Скрипт принимает два аргумента: имя хоста, с которого производится резервное копирование, и пароль суперпользователя root на этом хосте.01:

#!/usr/bin/expect -f
02: if {[llength $argv] != 2} {
03: puts "Вызов: auto_rsync.exp <ИМЯ_ХОСТА> <ПАРОЛЬ_ROOT>"
04: exit 1
05: }
06: set hostname [lindex $argv 0]
07: set password [lindex $argv 1]
08: set timeout -1
09: spawn date
10: expect -re "# $"
11: spawn rsync -av -e ssh $hostname:/etc /archive/sys
12: expect "password:" {send "$password\r"}
13: expect -re "# $"
14: spawn date
15: expect -re "# $"
16: spawn rsync -av -e ssh $hostname:/usr/etc /archive/sys
17: expect "password:" {send "$password\r"}
18: expect -re "# $"
19: spawn date
20: expect -re "# $"
21: spawn rsync -av -e ssh $hostname:/usr/work /archive/works
22: expect "password:" {send "$password\r"}
23: expect -re "# $"
24: spawn date
25: expect -re "# $"
26: exit 0

Здесь необходимы некоторые пояснения. В строке идентификации (01) использован флаг -f, непосредственно предваряющий файл, из которого считываются команды. Собственно говоря, он как раз и предназначен для #!-нотации с тем, чтобы в командной строке могли быть заданы другие аргументы. В нашем случае такими аргументами являются имя хоста и пароль суперпользователя.

В строках 02–05 выполняется проверка наличия названных выше аргументов, поскольку без них скрипт работать не будет.

С инициализацией переменных (строки 06 и 07) вы уже знакомы, а вот в строке 08 для переменной timeout задаётся значение -1, которое означает, что прерывания выполнения по тайм-ауту не будет, т.е. время ожидания не ограничено.

Фиксация даты и времени (строка 09 и далее по тексту) будет выполняться перед началом каждой операции и после её окончания.

В строках 11, 16 и 21 выполняется команда rsync, в которой флаг -a инициализирует режим архивирования, флаг -v позволяет выводить подробную информацию о ходе выполнения команды, а флаг -e предоставляет возможность задать командную оболочку: в нашем случае это ssh.

Скрипт можно выполнять из командной строки или запланировать его выполнение с помощью системных средств (cron или at), или поместить в скрипт-"обёртку" командной оболочки, в котором используется цикл для перебора всех необходимых хостов.

4. Организация совместной работы пользователей

Как уже было отмечено ранее, в состав установочного пакета Expect включены уже готовые скрипты, предназначенные для выполнения задач администрирования. Один из этих скриптов – kibitz – предоставляет весьма любопытные возможности.

Дон Либис с изрядной долей юмора дал такое имя (в переводе с английского kibitz – вмешиваться в чужие дела; давать непрошеные советы) скрипту, который позволяет двум или даже нескольким пользователям одновременно работать с одной программой: это может быть командная оболочка, текстовый редактор и т.д. Ограничение только одно – это должны быть программы с символьным (текстовым) интерфейсом. Запуск программ с графическим интерфейсом возможен, но при этом не гарантируется нормальный вид и поведение таких программ. Впрочем, это ограничение устраняется с помощью ещё одного скрипта xkibitz, который позволяет нормально работать с X-программами, а кроме того, обеспечивает динамическое подключение и отключение пользователей во время работы.

Для того чтобы начать работу, пользователь (назовём его user1) запускает скрипт, передавая ему в качестве аргумента имя другого пользователя, с которым он намеревается взаимодействовать (пусть это будет user2):kibitz user2

При этом активизируется новый экземпляр командной оболочки (или какая-либо другая программа, которую можно задать в командной строке), а пользователю user2 предлагается также выполнить скрипт kibitz. В приглашение включается уникальный идентификатор для того, чтобы избежать конфликтов с другими сеансами kibitz. В действительности этот идентификатор представляет не что иное, как просто идентификатор исходного процесса kibitz. Второй пользователь получает приблизительно такое сообщение:Can we talk? Run: kibitz -4077
EOF

После того как user2 выполнит указанную в сообщении команду (kibitz -4077), все нажатия клавиш обоих пользователей становятся вводом для общей командной оболочки. Соответственно, оба пользователя получают вывод оболочки.

Для того чтобы завершить сеанс kibitz, достаточно просто выйти из "совместной" командной оболочки, нажав клавиши Ctrl-D или введя команду exit. После выхода одного из пользователей происходит автоматический выход из оболочки и второго пользователя, в результате чего сеанс kibitz завершается.

В сетевой среде, когда вызываемый пользователь работает на другом хосте, команда инициализации сеанса kibitz выглядит следующим образом:

kibitz user2@host02

Канал связи создаётся с помощью утилиты rlogin. Если удалённый компьютер запрашивает пароль, то kibitz перехватывает этот запрос и предлагает вызывающему пользователю ввести требуемый пароль. Все прочие подробности установления соединения скрыты от пользователей.

После установления соединения и инициализации сеанса kibitz вторым пользователем всё выглядит так, как если бы оба пользователя работали на одном компьютере. Завершение сеанса производится точно так же, как описано выше.

Если необходимо организовать сеанс с участием более двух пользователей, то можно воспользоваться таким вариантом команды:

kibitz user2@host02 kibitz user3@host03 kibitz user4@host04

Такой "массовый сеанс" вполне пригоден, например, для обучения и для консультаций, когда опытный пользователь наглядно показывает начинающим, как выполняются различные операции, следит за их действиями, отвечает на вопросы и т.п. Разумеется, для организации подобного сеанса необходимо, чтобы на всех хостах-участниках был установлен пакет программ Expect.

Запуск консольного текстового редактора в kibitz-сеансе позволяет провести "интерактивное совещание" с ведением протокола или организовать совместное редактирование документов.

4.1. Использование kibitz как команды, встраиваемой в Expect-скрипты

Несмотря на то что kibitz является интерактивным скриптом (а с другой стороны – именно благодаря этому), его можно применять как команду, включаемую в сценарии автоматизации, написанные на Expect.

Предположим, что имеется Expect-скрипт, запускаемый сервисом cron или переведённый в фоновый режим выполнения. Обобщённая схема такого скрипта может выглядеть следующим образом:

01: spawn <некоторый_процесс>; set proc_id $spawn_id
...
<Expect-команды>
...
# предположим, что в ходе выполнения возможно возникновение проблемы
# или вопроса, требующего вмешательства пользователя
02: spawn kibitz -noproc <имя_пользователя>
03: send "Возникла ситуация, требующая вмешательства пользователя\n"
04: interact -u $proc_id
05: send "Проблема решена, продолжаю выполнение\n"

Здесь при инициализации сеанса kibitz (строка 02) используется флаг "-noproc", который позволяет обойтись без создания нового процесса, а вместо этого напрямую подключить создаваемый сеанс к текущему процессу. Таким образом, обеспечивается доступ заданного пользователя к выполняющемуся процессу, в котором возникла проблема.

Возможность выполнения пользователем необходимых действий предоставляется командой interact (строка 04). Эта Expect-команда устанавливает связь между двумя "сущностями". Первая "сущность" – это пользователь, которому передаётся управление процессом. Вторая "сущность" определяется с помощью флага "-u" с аргументом, которым обязательно должен быть идентификатор текущего процесса, требующего взаимодействия с пользователем.

После того как пользователь выполнит все необходимые действия и завершит интерактивный kibitz-сеанс, выдаётся соответствующее сообщение (строка 05), управление возвращается Expect-скрипту и его работа продолжится.

Об авторе

Алексей Снастин - независимый разработчик ПО, консультант и переводчик с английского языка технической и учебной литературы по ИТ. Принимал участие в разработке сетевых офисных приложений типа клиент/сервер на языке С в среде Linux.

 

 

autoexpect

Сегодня понадобилось воспользоваться expect, нашел удобную программу autoexpect, она устанавливается вместе с expect. С ее помощью можно легко создать скрипт который можно позже использовать. 

expect -c - устанавливает некоторую паузу в скрипте при вводе команд, иногда бывает полезно.

 

 

interact

interact – эта команда позволяет выполнить часть задач в "автоматическом режиме", а затем передать управление пользователю. В свою очередь, пользователь может в любой момент вернуть управление скрипту.

Каким образом можно вернуть управление скрипту???

Судя по ману, можно

Судя по ману, можно использовать
return
А если увидеть сам скрипт, то можно ответить более точно.

Отправить комментарий

CAPTCHA
Чтобы убедиться в том что Вы не робот, ответьте, пожалуйста, на вопрос
Fill in the blank