Как запускать команды как в очереди

atУтилита, самая известная для запуска команд в заданное время, также имеет функцию очереди и может быть предложена для запуска команды в настоящее время. Он читает команду для запуска со стандартного ввода.

echo 'command1 --option arg1 arg2' | at -q myqueue now echo 'command2 ...' | at -q myqueue now 

Команда batchэквивалентна at -q b -m now( -mимеется в виду, что выходные данные команды, если таковые имеются, будут отправлены вам по почте, как это делает cron). Не все варианты Unix поддерживают имена очередей ( -q myqueue); Вы можете быть ограничены одной вызванной очередью b. Linux atограничен однобуквенными именами очередей.

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

$ command1 & $ wait; command2 & $ wait; command3 & $ ... 

Решения Брэда и Манкова являются хорошими предложениями. Другое, похожее на их комбинацию, заключается в использовании GNU Screen для реализации вашей очереди. Преимущество этого в том, что вы можете работать в фоновом режиме, вы можете проверять его всякий раз, а добавление в очередь новых команд просто вставляет их в буфер, который будет выполняться после выхода из предыдущих команд.

Первый забег:

$ screen -d -m -S queue 

(кстати, сейчас самое время поиграть с некоторыми классными файлами screenrc ).

Это вызовет сеанс фонового экрана для вас с именем queue.

Теперь поставьте в очередь столько команд, сколько хотите:

screen -S queue -X stuff "echo first; sleep 4; echo second^M" 

Я делаю несколько команд в приведенном выше только для тестирования. Ваш вариант использования будет выглядеть примерно так:

screen -S queue -X stuff "echo first^M" screen -S queue -X stuff "echo second^M" 

Обратите внимание, что «^ M» в моей строке выше - это способ получить встроенный символ новой строки, который будет интерпретирован позже после того, как экран вставит его в существующую оболочку bash. Используйте «CTL-V», чтобы получить эту последовательность.

Было бы довольно легко сделать несколько простых сценариев оболочки для автоматизации этого и поставить команды в очередь. Затем, всякий раз, когда вы хотите проверить состояние фоновой очереди, вы повторно присоединяете через:

screen -S queue -r 

Технически, вам даже не нужно называть ваш сеанс экрана, и он будет работать нормально, но как только вы его зацепите, вы все равно захотите оставить его включенным. ;-)

Конечно, если вы сделаете это, другой хороший способ сделать это - назвать одну из текущих окон «очередь» и использовать:

screen -S queue -p queue -X stuff "command" 

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

Вот как я это сделал.

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

2. На компьютере, с которого вы перемещаете файлы (в дальнейшем называемом исходным компьютером), установите rsync apt-get install rsyncи Task Spooler с секретным соусом (веб-сайт http://vicerveza.homeunix.net/~viric/soft/ts/ ). Если вы используете Debian, имя пакета для tsis task-spoolerи исполняемый файл переименовываются, tspчтобы избежать конфликта имен с tsисполняемым файлом из moreutilsпакета. Пакет Debian, связанный с веб-сайтом, отлично устанавливается на Ubuntu dpkg -i task-spooler_0.7.3-1_amd64.debили аналогичном.

3. Также убедитесь, что на всех машинах установлен SSH apt-get install openssh-server. На исходном компьютере необходимо настроить SSH, чтобы разрешить вход без пароля на целевые компьютеры. Чаще всего будет использоваться метод аутентификации с открытым ключом ssh-agent( примеры приведены в https://www.google.se/search?q=ssh+public+key+authentication ), но иногда я использую более простой метод, который работает просто а также с аутентификацией по паролю. Добавьте следующее в вашу конфигурацию клиента SSH ( ~/.ssh/configили /etc/ssh/ssh_config):

   Host * ControlMaster auto ControlPath ~/.ssh/master-%r@%h:%p 

   Затем откройте один терминал на исходном компьютере, войдите в систему ssh target1, выполните обычную аутентификацию и оставьте этот терминал открытым. Обратите внимание, что существует файл сокета с именем ~/.ssh/master-user@target1:22, это файл, который будет держать аутентифицированную основную сессию открытой и разрешать последующие соединения без пароля user(пока соединение использует одно и то же целевое имя хоста и порт).

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

4. Теперь запустите ts rsync -ave ssh bigfile user@target1:для одного файла или ts rsync -ave ssh bigdir user@target1:для каталога. При использовании rsync важно не включать косую черту в каталог ( bigdirпо сравнению с bigdir/), иначе rsync будет предполагать, что вы имели в виду эквивалент bigdir/*большинства других инструментов.

   Диспетчер задач вернет приглашение и позволит вам поставить в очередь многие из этих команд подряд. Проверьте очередь выполнения tsбез аргументов.

Диспетчер задач имеет много функций, таких как перестановка очереди выполнения, запуск определенного задания только в случае успешного выполнения другого задания и т. Д. См. Справку ts -h. Иногда я проверяю вывод команды, пока он работает с ts -c.

Есть и другие способы сделать это, но для вашего случая использования они все включают диспетчер задач. Я решил использовать rsync поверх SSH для сохранения временных меток файлов, которых не было бы при копировании через SMB.

Мне тоже часто нужны такие вещи. Я написал небольшую утилиту под названием, afterкоторая выполняет команду всякий раз, когда завершается какой-то другой процесс. Это выглядит так:

#!/usr/bin/perl  my $pid = shift; die "Usage: $0 <pid> <command...>" unless $pid =~ /^\d+$/ && @ARGV;  print STDERR "Queueing process $$ after process $pid\n"; sleep 1 while -e "/proc/$pid"; exec @ARGV; 

Затем вы запускаете это так:

% command1 arg1 arg2 ... # creates pid=2853 % after 2853 command2 arg1 arg2 ... # creates pid=9564 % after 9564 command3 arg1 arg2 ... 

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

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

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

Пример следует. Вы можете вырезать и вставить все это или ввести последующие команды во время выполнения 1-го (если вы действительно очень быстро печатаете) или, скорее всего, во время выполнения 2-го:

echo "foo" sleep 10; echo "bar" sleep 3 echo "baz" 

Command1 && Command2

• «&&» означает, что команда2 выполняется только после того, как команда1 завершается с кодом возврата 0
• Примечание: a || означает, что команда2 выполняется только после того, как команда1 завершается с кодом возврата, отличным от 0

самый хакерский способ, который я могу придумать, - это поддерживать состояние очереди с помощью простых файлов блокировки в / tmp. когда file1.sh выполняет свои команды cp, он сохраняет файл блокировки (или жесткую ссылку) в / tmp. когда это будет сделано, удалите файл. каждый другой скрипт должен искать в / tmp файлы блокировки с выбранной вами схемой именования. Естественно, это подвержено всевозможным сбоям, но настроить его тривиально и выполнимо полностью в bash.