Linux выполнение последовательно команды

Объединения команд и обработка выходных данных в shell

Дата добавления: 07 апреля 2010

Объединение команд это очень полезная операция которую я сам очень часто применяю в терминале. Допустим вам нужно куда-то срочно уйти, но вы хотите скомпилировать что-либо. Вы знаете, что сначала нужно ввести ./configure потом make и только потом make install, при том окончание работы make иногда приходиться ждать час. В таких моментах придет объединение команд. Зная этот прием, вы введете ./configure && make && make install и уйдете по своим делам в то время как все нужные команды выполняться сами и полностью завершат компиляцию.
Можно даже добавить команду shutdown -h now в конец для отключения компьютера после выполнения всех операций.

Последовательное выполнение команд вне зависимости от исхода работы предыдущей.
Выполнить сколько угодно команд последовательно можно путем разделение команд символом ; (точка с запятой).
Пример:
./configure ; make ; make install
-выполняться все команды последовательно вне зависимости от исхода предыдущих.
То есть, если в ./configure будет выведено сообщение об ошибки, то интерпретатор все равно попробует выполнить make и make install .

Последовательное выполнение команд при условии успешного завершения предыдущих.
Символы && (два амперсанда) позволяют выполнять действие подобные предыдущей конструкции, но при не успешном завершении команды интерпретатор прекратит выполнение всего сценария.
Например:
./configure && make && make install
-если в ./configure будет ошибка, то последующие команды не будут исполняться. Если же все прошло удачно, то начнут выполняться make и make install притом если в make будет ошибка, то make install выполняться тоже не будет.

Выполнение команды, если предыдущая завершилась ошибкой.
Можно выполнить команды не только при успешном завершении предыдущей, но и при ошибочном завершении предыдущей с помощью символов || (две прямых черты).
Пример:
make install || echo ‘Ошибка!’
-выведется слово ошибка при неудачном завершении команды make install , иначе это слово выводиться не будет.

Использование выходных данных одной команды при вызове другой.
Давайте посмотрим на пример:
touch $(uname -r)
Эта команда создаст файл имя которого будет версия текущего ядра linux.
Команде touch передается с помощью конструкции $() команда выходные данные которой можно использовать для аргумента первой команды.

Источник

Урок 8. Объединение команд — последовательное и параллельное выполнение в bash

Символы групповых операций

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

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

Символ “ * ” указывает на любой символ в любом количестве. Поясним на примере.

У нас имеются следующие файлы:

Необходимо скопировать файлы image в каталог photo/. Для этого достаточно выполнить:

Символ » * « в данном случае означает любые символы после слова image , то есть image1.jpg , image2.jpg и так далее, включая image1.txt , image2.txt и image.pdf .

Чтобы лучше понять данный принцип рассмотрим возможные применения данного символа в таблице:

Все файлы image1.jpg — image15.jpg, image1.txt, image2.txt image.pdf

cp image*.jpg photo/

Только файлы image1.jpg — image15.jpg

Все файлы jpg : image1.jpg — image15.jpg

Абсолютно все файлы в текущем каталоге

Символ “ ? ” указывает на любой одиночный символ. Например, команда cp image?.jpg photo/ скопирует файлы с image1.jpg по image9.jpg , то есть между image и .jpg рассматривается только один знак.

Рассмотрим возможные применения данного символа:

cp image?.jpg photo/

Только с image1.jpg по image9.jpg

cp image1?.jpg photo/

Только с image10.jpg по image15.jpg

В нашем случае выдаст ошибку, так такого файла или каталога не существует

image1.jpg — image9.jpg, image1.txt и image2.txt

Следующий символ групповых операций — это квадратные скобки []. Внутри скобок помещается определенной выражение.

Например, [12] означает, что в условии должен совпасть один из символов, указанных в скобках, то есть либо 1 либо 2. Также можно задать целый диапазон значений — 1, то есть любой символ из указанного диапазона.

Поясним сказанное на примерах:

cp image[12].jpg photo/

Только файлы image1.jpg и image2.jpg

cp image13.jpg photo/

Только файлы image11.jpg — image15.jpg

cp image[12]* photo/

image1.jpg, image2.jpg, image1.txt, image2.txt

cp image?[13].jpg photo/

Только файлы image11.jpg — image13.jpg

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

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

Последовательное безусловное выполнение

Иногда при выполнении задач в Linux может потребоваться выполнить сразу целую последовательность команд.

Например, нам нужно создать каталог, скопировать группу файлов student*.jpg в данный каталог и проверить размер данного каталога в килобайтах.

Для этого мы выполним следующее:

cp student*.jpg photo/

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

mkdir photo; cp student*.jpg photo/; ls -lh

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

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

Последовательное выполнение при соблюдении условия

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

Например, из каталога photo/ нам нужно скопировать файлы на внешний носитель, а затем удалить их из каталога photo/. В принципе можно воспользоваться указанной ниже последовательностью

cp student*.jpg /media/StudentFlash; rm student*.jpg

И все будет работать, однако здесь одно НО. Если мы забудем подключить флэшку и выполним вышеуказанную последовательность, то потеряем все файлы student*.jpg , так как несмотря на ошибку система все равно выполнит вторую команду.

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

cp student*.jpg /media/StudentFlash && rm student*.jpg

То есть вместо символа » ; » (точка с запятой) мы используем » && » . Проще говоря, если первая команда завершилась с ошибкой (неважно какая), то система не выполнит вторую команду. Если первая команда завершилась успешно, то будет выполнена вторая команда.

Следующий символ объединения » || « используется, когда из 2-х (или более) команд нужно выполнить либо первую либо вторую команду. То есть, если первая команда завершилась с ошибкой, то ход переходит следующей команде, а если первая команда все же успешно завершилась, то вторая команда выполняться не будет.

Например, перейдем в каталог music/ , если его не существует то создадим его:

cd music/ || mkdir music

В нашем случае каталог music/ не существует и система выдала ошибку, поэтому будет выполнена команда mkdir music .

Передача выхода одной команды на вход другой команды

Иногда при работе с командой ls выводится слишком много информации, которая не помещается на всем экране и приходится прокручивать текст, чтобы увидеть начало

Чтобы постранично просматривать результат выполнения команд можно перенаправить вывод ls на вход команды less . Как мы уже знаем она используется для постраничного просмотра текстовых файлов. Для этого воспользуемся символом » | «:

Теперь попробуем в системе найти файл под названием icon с помощью команды locate (рассмотрим подробнее позже):

Система может выдать сотни и тысячи значений. Здесь тоже можем воспользоваться символом » | «:

locate * icon | less

Разумеется все это частные случаи. В процессе изучения новых команд и работе в Linux тебе придется не раз встречаться с ситуациями, когда будет необходимо воспользоваться символом » | « .

А можно результат работы locate записать в файл и уже потом просмотреть его содержимое с помощью less ?

Конечно можно. Для этого существует другой символ объединения команд » > « :

locate * icon > search_result.txt

В данном случаем символом » > » мы записываем результат выполнения locate в файл search_result.txt .

А файл search_result.txt нужно предварительно создавать?

Нет, если его нет, то система создаст его автоматически. А если он есть, то система перезапишет все его содержимое.

То есть мы можем все потерять по неосторожности?

Совершенно верно, но есть 2 способа избежать этого.

1-й способ. Можно установить специальную опцию noclobber :

set -o noclobber

Теперь, если файл существует, то система выдаст следующее сообщение:

Чтобы отключить эту опцию выполни

set +o noclobber

2-й способ. Вместо символа » > » воспользуйся символом » >> » . Когда указан этот символ система запишет данные в конец файла, тем самым сохранив предыдущие данные.

Подстановка вывода одной команды под аргумент второй команды

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

Вместо аргументов в некоторых случаях можно использовать и результаты выполнения некоторых команд.

К примеру, у нас имеется текстовый файл links.txt , где хранится следующая запись

Это простая текстовая строка. Попробуем подставить данную строку, чтобы создать каталоги согласно указанной строке. Для этого можно воспользоваться конструкцией типа $() :

mkdir $(cat links.txt)

Вывод команды cat был подставлен под аргумент команды mkdir .

Данная последовательность создает каталог по текущей дате.

Источник

Как запустить несколько команд Linux из одной строки

Практически для каждого администратора Linux командная строка становится основным инструментом для работы вместо любого графического интерфейса.

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

Возьмем, к примеру, возможность запуска нескольких последовательных команд из bash. Лучший пример этого — апдейт и апгрейд Ubuntu Linux. В командной строке bash вы можете сделать это, выполнив сначала команду sudo apt-get update, а затем команду sudo apt-get upgrade -y.

Но что, если бы вы могли объединить эти две команды в одну? Таким образом, вам не нужно сидеть сложа руки и ждать первой команды, прежде чем вводить вторую. К счастью, это на самом деле довольно просто. Есть два способа сделать это. Первый использует точку с запятой примерно так:

Единственная проблема этого метода заключается в том, что вторая команда будет запущена, даже если первая команда не будет выполнена. Могут быть случаи, когда вы не хотите, чтобы это произошло. В этих случаях вы запускаете команду:

Будут выполняться обе версии команды, но вторая форма будет выполнять вторую команду только в том случае, если первая завершится успешно.

Это очень важно, когда вы делаете такие вещи, как установка программного обеспечения из исходного кода. И вы можете сделать это с более чем двумя командами. Допустим, вы хотите обновить, обновить и автоматически удалить с помощью apt. Сделайте это с:

И вот как вы можете легко запустить последовательно несколько команд из bash.

Источник

Кунг-фу стиля Linux: запуск команд

Одна из особенностей Linux- и Unix-подобных операционных систем, возможность мощная, но, в то же время, вызывающая немало путаницы, заключается в том, что в этих системах до одной и той же цели можно добраться разными путями. Возьмём, например, что-то простое, вроде запуска последовательностей команд. Как это сделать? Пожалуй, самый очевидный ответ на этот вопрос заключается в написании shell-скрипта. Это — потрясающе гибкий подход к решению подобной задачи. Но что если нужно всего лишь запустить несколько команд, по возможности ничем не усложняя себе жизнь? Выглядит такая задача весьма простой, но существует множество способов решить её — от простого ввода этих команд в командной строке, до планирования их запуска. За выполняющимися командами, кроме того, можно наблюдать, организовав мониторинг очереди задач так, как он может быть организован на мейнфрейме.

Поговорим о запуске команд в Linux, рассмотрим несколько способов запуска последовательностей команд из bash (и из многих других оболочек Linux). Здесь мы коснёмся таких вопросов, как использование утилит cron и at , поговорим о системе пакетного выполнения команд с использованием очереди (task spooler). Я, как и в большинстве случаев обсуждения возможностей Linux, не могу сказать, что то, о чём я хочу рассказать, хотя бы близко подходит к полному освещению способов запуска команд в Linux. Но я надеюсь, что мой рассказ даст вам некоторые идеи относительно управления выполнением последовательностей команд.

Запуск команд из командной оболочки

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

Этот приём работает в большинстве командных оболочек, которые более или менее похожи на bash. Он хорошо подходит для запуска простого набора команд. Команды просто выполняются последовательно. Но что если надо запустить нечто вроде такой конструкции:

Не запускайте эту последовательность команд в реальной системе!

Нам нужно стереть в папке foo все файлы (но не подпапки — для этого нужен ключ -r ). А что если не удастся выполнить команду cd ? Тогда будут стёрты все файлы в текущей папке. А это — очень плохая идея, которая, к тому же, нарушает правило наименьшего удивления.

Защититься от вышеописанной проблемы можно, воспользовавшись оператором && . Эта последовательность символов, как и в языке C, представляет собой оператор И . Практически все Linux-команды возвращают, успешно отработав, 0, что воспринимается как истинное значение, а все остальные значения, указывающие на ошибки, считаются ложными. Это позволяет программистам возвращать коды ошибок при возникновении в программах каких-то проблем. Вот более удачный вариант вышеописанного примера:

Если директория foo существует — команда cd вернёт 0, который будет воспринят как истинное значение. Это означает, что результат операции И может быть истинным. Поэтому работа продолжается и выполняется команда ls . А вот если команду cd выполнить не удастся — результат будет ложным. Если любое из входных значений функции, реализующей логику оператора И , является ложным, то остальные входные значения роли уже не играют. В результате если хотя бы одна из частей этой конструкции вернёт ложное значение — выполнение всей последовательности команд будет остановлено. Получается, что если директории /foo не существует — команда ls попросту не выполнится.

С использованием && можно строить и более длинные конструкции.

Более длинная конструкция, в которой используется && (тут тоже есть rm, поэтому будьте очень осторожны, пытаясь запустить нечто подобное в реальной системе)

В ситуациях, подобных вышеописанной, может найти применение ещё один оператор — || ( ИЛИ ). Он позволяет завершить работу после того, как хотя бы одна команда вернёт истинное значение, то есть — отработает успешно. Например:

Попробуйте, вместо alw , ввести своё имя пользователя, а потом испытайте эту конструкцию с именем пользователя, которого в вашей системе нет (уверен, у вас нет пользователя alw ). Если grep отработает успешно, то команда echo выполнена не будет.

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

Планирование запуска команд в определённое время

Иногда нужно, чтобы последовательность команд запустилась бы спустя некоторое время от текущего момента, или чтобы команды были бы выполнены в заданное время. Классический инструмент, используемый для решения подобных задач — это утилита cron . Во многих дистрибутивах есть стандартные директории, позволяющие запускать команды, например, каждый час или каждую минуту. Но лучше всего планировать запуск команд путём редактирования файла crontab . Обычно сначала создают скрипт, а потом уже делают запись о нём в crontab . Правда, необходимость в создании скрипта для запуска нескольких команд возникает далеко не всегда.

Файл crontab редактируют, пользуясь одноимённой командой ( crontab -e ). Каждая строка этого файла, не являющаяся комментарием, описывает некую команду, которую нужно выполнить. Первая часть такого описания сообщает о том, когда именно нужно выполнить команду. Вторая часть содержит указание на саму команду. Например, вот запись, позволяющая запустить команду обновления duckdns:

В начале строки находится описание времени запуска команды — минуты, час, день месяца, день недели. Конструкция */5 указывает на то, что команду нужно запускать каждые 5 минут. Символы * являются универсальными местозаполнителями, представляющими любой час, день месяца и так далее. Есть множество особых конструкций, которыми можно пользоваться в подобных описаниях. Для того чтобы упростить их составление — можете попробовать этот crontab-редактор. Пример работы с ним показан ниже.

Работа с crontab-редактором

Правда, при использовании cron можно столкнуться с одной проблемой. Она заключается в том, что логика утилиты основана на предположении о том, что компьютер работает в режиме 24/7. Так, если запланировать запуск некоей задачи на ночь, а ночью компьютер будет выключен — задача выполнена не будет. Есть ещё одна утилита, anacron , которая создана в попытке исправить этот недостаток. Она, учитывая некоторые ограничения, похожа на cron , но она «навёрстывает упущенное» в том случае, если на момент запланированного запуска некоей задачи компьютер был выключен.

Иногда нужно выполнить некую команду в заданное время лишь один раз. Сделать это можно с помощью команды at :

В ответ на эту команду будет показано простое приглашение командной строки, с помощью которого можно вводить команды. В данном случае эти команды будут выполнены через 10 минут. Эта команда, конечно, поддерживает и указание абсолютных временных значений. Кроме того, программа вас поймёт, если вы вместо 4PM сообщите ей о «teatime» (серьёзно). Команда atq позволяет просмотреть список запланированных задач. А команда atrm позволяет отменять запуск запланированных команд. Это пригодится в том случае, если по какой-то причине в выполнении запланированной команды больше нет необходимости. Если воспользоваться пакетной формой команды ( batch ), система выполнит команды тогда, когда нагрузка на неё будет не слишком высокой.

Если почитать справку по at , то можно узнать о том, что утилита, по умолчанию, использует очередь a для обычных задач, а очередь b для пакетных задач. Для указания очередей можно использовать буквы из диапазонов a-z и A-Z. От имени очереди зависит приоритет помещённых в неё задач.

Тут мне хотелось бы отметить то, что в большинстве систем все задачи, поставленные в очередь, будут выполняться в оболочке, заданной как оболочка, используемая по умолчанию (вроде /bin/sh ), и это необязательно будет bash. Может понадобиться использовать именно bash, или протестировать команды в оболочке, используемой по умолчанию. Если просто запустить скрипт, в котором, в качестве интерпретатора указан bash (например — #!/usr/bin/bash ), то это будет незаметно.

Пакетное выполнение задач

Хотя утилита at имеет вариант, выглядящий как batch , её нельзя назвать полноценной системой, предназначенной для пакетного выполнения задач. Существует несколько подобных систем для Linux, обладающих различными особенностями. Одна из таких систем называется Task Spooler (в репозиториях Ubuntu — task-spooler ). В некоторых системах соответствующая команда выглядит как ts , но в Debian использование подобного имени команды приводит к конфликту, поэтому там используется команда tsp .

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

Первая команда запускает, в виде задачи, утилиту wget (это, на самом деле, задача 0). Выполнение команды tsp позволяет просмотреть список задач, находящихся в очереди (в данном случае это — всего одна задача, которая уже завершена). Опция -i позволяет просмотреть сведения об указанных задачах. Опция -c выводит выходные данные задачи. Опцию -c можно воспринимать как нечто вроде команды cat . Ещё одна опция, -t , похожа на опцию -f команды tail . Выходные данные задачи можно, кроме того, отправить по электронной почте, воспользовавшись опцией -m .

Обычно система пакетного выполнения задач выполняет одновременно лишь одну задачу. Это можно изменить, воспользовавшись опцией -S . Можно сделать так, чтобы некая задача ожидала бы, перед запуском, окончания работы предыдущей задачи. Это делается с помощью опции -d . Запуск задачи можно связать и с окончанием произвольно выбранной задачи — для этого используется опция -w .

Если вы читали справку по tsp , то вы могли обратить внимание на то, что эта команда поддерживает и множество других опций. Перед тем, как воспользоваться этой командой в некоей системе, стоит помнить о том, что она может выглядеть не как tsp , а как ts . Примеры использования этой утилиты можно найти на её сайте.

Итоги

Как и во многих других ситуациях, возникающих при работе в Linux, вышеописанные способы запуска наборов команд можно комбинировать. Например, можно сделать так, чтобы cron поставил бы задачу в очередь. А сама эта задача может представлять собой скрипт, в котором применяются операторы && и || , управляющие внутренней логикой выполнения набора команд. Думаете, что это неоправданно сложно? Может быть. Как я уже говорил, можно просто взять и написать обычный скрипт. Но в Linux есть и много других полезных механизмов для решения самых разных задач.

Как вы обычно запускаете наборы команд в Linux?

Источник