LinuxCamp | Кирилл Жильников

Channel
Logo of the Telegram channel LinuxCamp | Кирилл Жильников
@linuxcamp_tgPromote
7.2K
subscribers
Авторский канал по изучению системы Linux и ее администрированию. Админ (реклама): @XoDefender Менеджер: @Spiral_Yuri Биржа: https://telega.in/c/linuxcamp_tg
1000 & 1 способ: решение

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

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

Сразу не пугайтесь, все разберем:


$ seq 1 10 | xargs -I{} bash -c "echo \"file{}.txt\" > file{}.txt"


1) seq 1 10 - генерирует последовательность чисел 1-10. Каждое число будет выведено в новой строке:


$ seq 1 10
1
2
3
...


2) конвейер '|' - используется для того, чтобы команда xargs получила на вход (STDIN) вывод (STDOUT) предыдущей команды seq.

В результате xargs будет работать с последовательностью 1-10;

3) "xargs -I{}" - утилита xargs позволяет выполнять произвольную команду для одного либо нескольких входных значений. В данном случае входные значения передаются через конвейер.

Мы детально ее разберем отдельно. Пока вам нужно знать только то, что xargs выполнит "bash -c" для каждого элемента от 1 до 10.

"-I{}" позволяет определить место входных данных в сгенерированной команде. По умолчанию они идут в конец. Вместо "{}" может быть что угодно. Это, своего рода, шаблон.

В результате каждый элемент 1-10 будет подставлен в нужное нам место внутри команды:


$ seq 1 10 | xargs -I{} echo "file{}.txt"
file1.txt
file2.txt
file3.txt


4) "bash -c" - ну тут-то вы уже подкованы).

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

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

Вернее, '>' вообще не будет частью xargs и отработает в первую очередь, еще до самой команды:


$ seq 10 | xargs -I{} echoo file{}.txt > file{}.txt
xargs: echoo: No such file or directory

$ ls
file{}.txt


5) "echo \"file{}.txt\" > file{}.txt" - строка, которую bash выполнит для каждого значения от 1 до 10 ({}).

"echo \"file{}.txt\" > file{}.txt" - записывает текст fileX.txt в файл fileX.txt. Сам файл создается при перенаправлении вывода, которое мы разбирали тут.

\"\" - экранирование символов, которое необходимо, чтобы избежать разрыва, т.к. строка команды также находится внутри двойных кавычек.

Обратный слэш сообщает bash, что кавычки - это часть текста, а не завершающий символ;

LinuxCamp
1000 & 1 способ: задача

Данная рубрика отражает возможность в Linux выполнить одну и ту же задачу "1000 & 1" изощренным способом.

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

Задача: наиболее интересно, используя команду/команды Bash, создать в одном каталоге 10 файлов "file1.txt, file2.txt ..." и заполнить их текстом названия:


$ ls
file10.txt file1.txt file2.txt file3.txt file4.txt file5.txt file6.txt file7.txt file8.txt file9.txt


$ cat file9.txt
file9.txt


LinuxCamp
🔥 Гитхаб В С Ё!

А у нас для тебя ежедневная подборка лучших проектов с открытым исходным кодом 👇

Подпишись на Useful Tools и тебе больше не придется работать.

Потому что, за тебя всё сделали и придумали. Возьми готовое и нажми Enter.

Каждый день админ выбирает трендовые репозитории и делает из них тематические подборки.

Никакого шлака, только мастхэв и бест-практики.


- Подборка утилит для ssh
- Подключи OneDrive в Linux
- Телеграм как бесплатное облако
- Делаем свой github pages

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

Подпишись 👉 Useful Tools
Запускаем чат LinuxCamp

Нас уже немало набежало и пришло время укреплять комьюнити)

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

Если вы хотите окружить себя единомышленниками, перенимать опыт и делиться им, welcome в LinuxCamp | Chat.
Явные подоболочки

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

С дочерними оболочками так не работает - тот же алиас мы должны определить в конфиге, иначе она его не сможет использовать.

Подстановка команд, которую мы рассматривали, отрабатывает в подоболочке и возвращает вывод.

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

Для этого просто заключим команду в круглые скобки:


$ (cd /usr/local && ls)
bin etc games lib man sbin share

$ pwd
/home/smith


Как видим, первая команда выполнилась в подоболочке и не поменяла текущую рабочую директорию => нам не нужно повторно вызывать cd.

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

Предположим, нам нужно через команду tar извлечь файлы из архива в определенный каталог. Можно выполнить задачу несколькими способами:

1) изи - использовать флаг "" c указанием путь:


$ tar -xzf package.tar.gz -C ./extr


2) хардкор - передать tar-данные в подоболочку, которая зайдет в нужный каталог и выполнит архивирование из стандартного вывода (STDOUT):


cat package.tar.gz | (cd ./extr && tar xzvf -)


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


$ dpkg-buildpackage -b -us -uc && (cd ..; ls -l)


Раньше приходилось держать доп. терминал, по сути, для 1 примитивной задачи)

LinuxCamp
Передача команды в качестве bash аргумента

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

По умолчанию bash запускает интерактивную оболочку для ввода и выполнения команд.

Кроме того, можно передать команду в bash в виде строки с помощью параметра "-c".

Тогда bash запустит эту строку как команду, а после выполнения завершит работу:


$ bash -c "ls -l"
-rw-r--r-- 1 smith smith 325 Jul 3 17:44 animals.txt


Почему это бывает полезно?

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

Любые изменения в дочерней оболочке не повлияют на текущую:


$ pwd
/home/smith

$ touch /tmp/badfile

$ bash -c "cd /tmp && rm badfile"

$ pwd
/home/smith


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

Однако наиболее показательно и полезно использование "bash -c" вместе с sudo и перенаправлением ввода/вывода. Тогда-то эта фича является ключом к успеху.

Предположим, вы хотите создать файл журнала в системном каталоге "/var/log", недоступном для записи обычным пользователям.

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


$ sudo echo "New log file" > /var/log/custom.log

bash: /var/log/custom.log: Permission denied


Минуту, команда sudo должна дать разрешение на создание любого файла в любом месте. Как что-то может пойти не так?

Почему sudo даже не запрашивает пароль? Ответ: потому что sudo вообще не запускалась.

Вы применили sudo к команде echo, но не к перенаправлению вывода, которое запустилось первым и провалилось.

Опишем процесс пошагово:

1) вы нажали клавишу Enter;

2) оболочка начала вычислять всю команду, включая перенаправление;

3) оболочка попыталась создать файл custom.log в защищенном каталоге "/var/log";

У нас не было разрешения на запись в "/var/log", поэтому оболочка сообщила, что в доступе отказано (Permission denied).

Чтобы решить эту проблему, нужно сообщить оболочке:

«Выполни всю команду, включая перенаправление вывода, от имени суперпользователя».

Это именно та ситуация, которую так хорошо решает "bash -c".

Создайте команду, которую вы хотите запустить, в виде строки и передайте ее в качестве аргумента для "sudo bash -c":


$ sudo bash -c 'echo "New log file" > /var/log/custom.log'

[sudo] password for smith: xxxxxxxx

$ cat /var/log/custom.log
New log file


На этот раз мы запустили от имени суперпользователя bash, а не просто echo.

По итогу, bash выполнит всю строку как команду. Перенаправление проходит успешно.

Помните о "bash -c", когда sudo сочетается с перенаправлением.

LinuxCamp
Проблема с вводом-выводом в фоновом выполнении

Фоновая команда может использовать стандартный вывод, когда это совершенно не к месту)

Что будет, если вы, например, отсортируете немалый файл и запросите вывод двух первых строк в фоновом режиме?

Вначале оболочка напечатает номер задания (1), идентификатор процесса (81089) и приглашение к вводу:


$ sort /usr/share/dict/words | head -n2 &
[1] 81089
$


На данном этапе происходит сортировка данных и подготовка вывода. Когда первая часть задания завершится, отработает команда "head -n2" и выведутся две строки (где бы курсор не находился):


$ sort /usr/share/dict/words | head -n2 &
[1] 81089
$A
A's


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

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


$ sort /usr/share/dict/words | head -n2 > /tmp/results &


$ cat /tmp/results
A
A's


Неожиданности случаются и тогда, когда фоновое задание пытается читать со стандартного ввода. Оболочка приостанавливает задание, печатает сообщение Stopped и ожидает ввода. Запустив команду cat в фоновом режиме без аргументов, чтобы она читала STDIN:


$ cat &
[1] 82455
[1]+ Stopped cat


Задания не могут читать ввод в фоновом режиме, поэтому сначала переведем его на передний план с помощью fg, а затем введем данные:


$ fg
cat
Hello world!
Hello world!


После ввода можно уже либо завершить задачу "Ctrl + C", либо вернуть ее в фон через "Ctrl + Z" и bg.

🐧 LinuxCamp
Please open Telegram to view this post
VIEW IN TELEGRAM
Выбираем название канала

Для лучшего поиска нужно добавить 1 слово, которое бы выделяло канал. Если есть идеи, обязательно пишите в комменты)
Final Results
20%
Baza Linux++
12%
DevHub Linux++
5%
Crazy Linux++
26%
GNU/Linux++
34%
Pro Linux++
4%
BrainBar Linux++
3%
Mania Linux++
22%
Все не то
Команды управления заданиями

В прошлый раз мы узнали о фоновом выполнении команд и дали определение термину "задание".

Сегодня рассмотрим, встроенные в оболочку средства, которые позволяют управлять заданиями: bg, fg, jobs, kill.

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


$ sleep 10 & sleep 20 & sleep 30 &


Чтобы выяснить, за какими заданиями следит оболочка, используется команда jobs:


$ jobs
[1] Running sleep 10 &
[2]- Running sleep 20 &
[3]+ Running sleep 30 &


[1] - номер задания, который используется для идентификации. Полезен, когда необходимо "ткнуть пальцем" в определенный элемент, используя: fg, bg, kill;

"" (отсутствие знака) - обозначает то, что задание не является ни текущим ни предыдущим, но находится в списке.

"+" указывает на текущее задание, по отношению к которому будут выполнены команды, если не указывать номер. "-" указывает на предыдущее задание;

Running - статус задачи. Также возможны: Stopped, Done, Terminated, Killed. Статусы могут меняться в ответ на отправленный сигнал (SIGKILL, SIGSTOP и т.д.);

Теперь выведем второе задание на передний план. Для этого будем использовать команду fg с указанием номера:


$ fg %2
sleep 20


Если в параметры ничего не вносить, команда выполнится для последнего задания (со знаком +).

Для того, чтобы перенести выполнение в фон и не блокировать терминал, используется bg.

Для примера запустим задание переднего плана, остановим его выполнение "Ctrl + Z" и отправим его в фоновый режим:


$ nm-applet
^Z
[1]+ Stopped nm-applet

$ bg
[1]+ nm-applet &

$ jobs
[1]+ Running nm-applet


К целевому заданию также можно обратиться по номеру:


$ jobs
[1]- Stopped sleep 200
[2]+ Running sleep 100 &

$ bg %1
[1]+ sleep 200 &


С заданиями "kill %n" можно использовать для принудительного завершения:


$ kill %1
[1]+ Terminated sleep 200


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


$ kill -9 %1
[1]+ Killed sleep 200


🐧 LinuxCamp
Please open Telegram to view this post
VIEW IN TELEGRAM
Введение в фоновые команды и задания

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

Это обычно неэффективно, когда выполнение занимает время и вам не требуется общаться с утилитой через CLI либо отлаживать ее логи.

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

Этот метод называется фоновым выполнением команды (backgrounding).

Если же команда занимает оболочку, ее называют командой переднего плана (foreground).

Запуск команды в фоновом режиме

Чтобы запуститься в фоновом режиме, просто добавьте амперсанд "&" после команды:


$ wc -c file.txt &
[1] 74931
$


[1] - номер, под которым закрепилось задание (job);
74931 - PID процесса;

Если команда завершится успешно, оболочка выведет сообщение:


[1]+ Done wc -c file.txt


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


[1]+ Exit 1 wc -c file.txt


Амперсанд "&" является оператором списка - вы можете вывести в фон сразу ряд команд:


$ nm-applet & wc -c file.txt &
[1] 28839
[2] 28840


Чем является задание?

Вы можете подумать, что под заданием подразумевается 1 процесс - немного не так.

Задание — это единица работы оболочки. Простые команды, конвейеры и условные списки — примеры заданий, которые можно запускать из командной строки.

Задание — это больше, чем просто процесс Linux. Задание может состоять из одного или нескольких процессов:


[4]+ Running nm-applet && wc -c file.txt &


Например, конвейер из шести программ представляет собой одно задание, включающее 6 процессов:


$ cat file.txt | grep "word" | sort | uniq | tr 'a-z' 'A-Z' | wc -l > result.txt &


[5]+ Running cat file.txt | grep --color=auto "word" ... &


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

🐧 LinuxCamp
Please open Telegram to view this post
VIEW IN TELEGRAM
Подстановка вывода команды: $()

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

Предположим, у вас есть несколько тысяч текстовых файлов c песнями. Каждый файл содержит название песни, ее текст и имя исполнителя:


Название: Зеркала
Исполнитель: Лепс
Острые углы, нервы, суета


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


$ grep -l "Лепс" *.txt
song1.txt
song2.txt


Затем переместить каждый файл в необходимый каталог:


$ mkdir leps
$ mv song1.txt leps
$ mv song2.txt leps


Чет неудобно, так? Было бы неплохо сказать оболочке: «Перемести все файлы, содержащие строку Лепс, в каталог leps».

Для этого нужно забрать то, что нам выдала команда "grep -l" и передать результат в качестве списка аргументов для mv:


$ mv $(grep -l "Лепс" *.txt) leps


Синтаксис "$(команда)" выполняет выражение в круглых скобках и заменяет вставку его выводом.

Таким образом, "grep -l" подменяется, подходящими под условие именнами файлов. Результат использования $() в примере выше аналогичен:


$ mv song1.txt song2.txt leps


В сценариях оболочки подстановка бывает полезна для сохранения вывода команды в переменной:


переменная=$(команда)


Например, напишем простенький скрипт, который поможет нам узнать, содержит ли текущая директория файлы:


status=$(ls ./ 2>/dev/null | wc -l)

if [ "$status" -gt 0 ]; then
echo "В директории есть $status файлов"
else
echo "Директория пуста или не существует"
fi


Выдаем права на выполнение, запускаем и проверяем:


$ chmod +x script.sh
$ ./script.sh
В директории есть 66 файлов


Для чего бывает полезно брать "$()" в кавычки?

Есть несколько основных кейсов, когда следует использовать "$()" вместо $().

Во-первых, если вывод команды содержит пробелы, он будет разбит на отдельные слова.

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

Есть момент - имя каталога состоит из нескольких слов, разделенных пробелами "photo and video":


$ pwd
$ /home/xoadmin/photo and video
$ chmod 777 $(pwd)


После подстановки оболочка интерпретирует это как попытку применить chmod к трём разным объектам: "/home/xoadmin/photo", "and", и "video". Это, вероятно, приведёт к ошибке:


chmod: cannot access '/home/xoadmin/photo': No such file or directory

chmod: cannot access 'and': No such file or directory

chmod: cannot access 'video': No such file or directory


Чтобы вывод pwd воспринимался, как единое целое, следует заключить оператор в кавычки:


$ chmod 777 "$(pwd)"


Во-вторых, без кавычек, символы перевода строки могут быть удалены при выводе через echo:


$ echo $(ls)
adduser.conf alsa alternatives apache2 apg.conf apparmor


Если требуется сохранить четкую структуру текста, содержащего спец символы, следует использовать "$()":


$ echo "$(ls)"
adduser.conf
alsa
alternatives


🐧 LinuxCamp
Please open Telegram to view this post
VIEW IN TELEGRAM
Что за праздник на пороге?) Новый год 🔴

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

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

Представляете, ! Я, честно говоря, думал, и до 5 с трудом доковыляем. Но как-то все пошло-поехало и получилось зафиксировать хороший результат. Очень рад, что в этом году все-таки получилось начать движение в сторону публичной деятельности. Мы держим в уме - все только начинается!

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

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

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

На этом прощаюсь, с наступающим праздником!
Please open Telegram to view this post
VIEW IN TELEGRAM
Выполняй только то, что нужно! Условные списки Bash

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

Механизм списков позволяет не только разом выполнить группу команд, но и выстроить условную последовательность через операторы "&& (И)" и "|| (ИЛИ)".

Условные списки

Предположим, вы хотите создать файл new.txt в каталоге dir. Типичная последовательность может быть следующей:


$ cd dir
$ touch new.txt


Запуск второй команды зависит от успешного выполнения первой. Если каталог не существует, то нет смысла и команду запускать.

Оболочка позволяет сделать эту зависимость явной, объединив команды оператором && (И):


$ cd dir && touch new.txt


Если вы используете систему контроля версий Git, то, вероятно, знакомы со следующей последовательностью команд фиксации и внесения изменений:


$ git add . && git commit -m"fixed a bug" && git push


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

Так же, как оператор && запускает вторую команду только в случае успеха первой, оператор || (ИЛИ) запускает вторую команду только в случае сбоя первой.

Например, следующая команда пытается войти в каталог и, если это не удается, создает его:


$ cd dir || mkdir dir


Вы часто будете видеть этот оператор в сценариях оболочки. В частности, для выхода в случае возникновения ошибки:


cd dir || exit 1


Операторы && и || можно использовать вместе, чтобы настраивать более сложные действия:


$ cd dir || mkdir dir && cd dir || echo "I failed"


Последовательность предполагает попытку войти в каталог dir, если это не удается, создать каталог и войти в него, а если и это не удается, вывести ошибку.

Безусловные списки

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

Вот пример команды, которая спит течение двух часов, а затем создает резервную копию важных файлов:


$ sleep 7200; cp -a ~/files /mnt/backup_drive


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

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

Только код возврата последней команды в списке присваивается переменной оболочки "?":


$ mv file1 file2; mv file2 file3; mv file3 file4

# Код возврата команды «mv file3 file4»
$ echo $?
0


🐧 LinuxCamp
Please open Telegram to view this post
VIEW IN TELEGRAM
Вычисление переменных и развеивание заблуждений

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

Когда командная оболочка вычисляет переменную, определяет ее значение и подставляет его вместо имени. Чтобы выполнить задачу, нужно просто поставить знак $ перед именем.

Самый простой способ увидеть, как оболочка обрабатывает символ — запустить команду echo, которая выводит свои аргументы (после того, как оболочка завершит их вычисление):


$ echo My name is $USER and my files are in $HOME

My name is xoadmin and my files are in /home/xoadmin

$ echo ch*ter9
chapter9


Когда вы выводите на экран значение переменной с помощью команды echo, вы можете подумать, что сама команда проверяет переменную и выводит ее значение.

На самом деле это не так, команда ничего не знает о переменных. Она просто выводит на экран любые аргументы, которые вы ей передаете. Значения для HOME и USER вычисляет оболочка перед запуском команды.

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


name=value


Например, если вы часто работаете с каталогом "Projects" внутри домашней директории, вы можете присвоить его имя переменной:


$ work=$HOME/Projects


И использовать его как удобное сокращение при работе с cd:


$ cd $work
$ pwd
/home/xoadmin/Projects


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


$ cp myfile $work
$ ls $work
Myfile


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

Шаблоны vs переменные

Предположим, вы хотите перенести ряд файлов с расширением ".txt" из одного каталога в другой.

Вот два способа сделать это, но один работает, а другой нет:


# Метод 1
$ mv dir1/*.txt dir2

# Метод 2
$ FILES="file1.txt file1.txt"
$ mv dir1/$FILES dir2


Метод 1 работает, потому что шаблон соответствует всему пути к файлу — имя каталога dir1 является частью совпадений:


$ echo dir1/*.txt
dir1/file1.txt dir1/file2.txt


Таким образом, метод 1 работает так, как если бы вы набрали следующую команду:


$ mv dir1/file1.txt dir1/file2.txt dir2


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


$ echo dir1/$FILES
dir1/file1.txt file2.txt


Следовательно, метод 2 работает так, как если бы вы набрали следующую команду:


$ mv dir1/file1.txt file2.txt dir2

/bin/mv: cannot stat 'file2.txt': No such file or directory


🐧 LinuxCamp
Please open Telegram to view this post
VIEW IN TELEGRAM
Please open Telegram to view this post
VIEW IN TELEGRAM
Операторы перенаправления ввода-вывода [3]

Я же уверен, что 80% из вас когда-то использовали оператор "|". Он невероятно полезен - позволяет подключить стандартный вывод (STDOUT) одной команды к стандартному вводу (STDIN) другой, чтобы первая смогла передать свои выходные данные во вторую.

Вертикальная черта "|" между командами — это символ канала (pipe), который реализовывает механизм конвейера (pipeline).

Посмотрим на самый узнаваемый сценарий работы конвейера - отфильтровать вывод по шаблону:


$ ls /usr/lib | grep nma
libnma.so.0
libnma.so.0.0.0


В результате мы видим не все содержимое директории, а только то, с чем grep нашел пересечение по шаблону.

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


ls (STDOUT) -> grep (STDIN) -> grep (STDOUT)


Тут уже оболочка, на своем уровне, выполняет всю магию и использует системный вызов "pipe()" для перенаправления:


#include <unistd.h>

int pipe(int pipefd[2]);


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

Допустим, мы хотим узнать, сколько подкаталогов находится в "/usr/lib". Нет простой команды для получения ответа, поэтому создадим конвейер.

Начнем с простого вывода содержимого директории. Обратите внимание, что команда "ls –l" помечает каталоги буквой "d" в начале строки:


$ ls -l /usr/lib
drwxrwxr-x ... 4kstogram
drwxr-xr-x ... NetworkManager


Используем cut, чтобы вывести первый столбец:


$ ls -l /usr/lib | cut -c1
d
d
d
-
-
-


Затем используем grep, чтобы оставить только строки, содержащие букву "d":


$ ls -l /usr/lib | cut -c1 | grep d
d
d
d


Наконец, подсчитаем строки с помощью команды wc и получим ответ, созданный конвейером из четырех команд:


$ ls -l /usr/lib | cut -c1 | grep d | wc -l
145


Результат: директория "/usr/lib" содержит 145 подкаталогов.

Что мы сделали? Превратили небольшую горстку команд в набор комбинируемых инструментов. Как говорится, целое всегда есть нечто большее, чем сумма его частей.

🐧 LinuxCamp
Please open Telegram to view this post
VIEW IN TELEGRAM
Операторы перенаправления ввода-вывода [2]

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

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


$ tr 'a-z' 'A-Z'
hello
HELLO


Команда не получает файл в качестве аргумента. Чтобы все-таки скормить ей статический поток данных, можно использовать то самое перенаправление STDIN:


$ cat animals.txt
1 retriever
2 badger

$ tr 'a-z' 'A-Z' < animals.txt
1 RETRIEVER
2 BADGER


Оператор '<<' heredoc

Оператор '<<' дает возможность перенаправлять многострочный поток данных (массив строк) на вход программе:


$ cat << EOF
> Сurrent user: $(whoami)
> Status: sysadmin
> EOF
Сurrent user: parallels
Status: sysadmin


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

Как работает "heredoc"

После оператора указывается метка (произвольное слово), которая обозначает начало и конец текста.

Все строки между метками считаются входными данными для команды. Когда оболочка повторно встречает слово, которое шло сразу за '<<', ввод завершается:


$ cat << EOF > config.conf
[settings]
host=localhost
port=8080
debug=true
EOF


В примере выше мы отправили команде cat на вход (STDIN) массив строк, вывод (STDOUT) которых перенаправили в конфиг.

Еще одним полезным примером может быть передача SQL-запросов в БД через ручной ввод:


$ mysql -u root -p << EOF
CREATE DATABASE my_database;
USE my_database;
...
EOF


🐧 LinuxCamp
Please open Telegram to view this post
VIEW IN TELEGRAM
Операторы перенаправления ввода-вывода [1]

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

Сделаем серию из 3 постов. Сегодня рассмотрим операторы для перенаправления вывода STDOUT и STDERR: >, >>. В следующие разы поговорим про STDIN и завершим тему оператором '|'.

Перенаправление потоков вывода:

Предположим, вы хотите создать файл, в который будет записан вывод STDOUT какой-то программы (разберем на примере date).

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


$ date > date.txt
$ cat date.txt
Sat Dec 14 20:50:46 MSK 2024


Перенаправление вывода с использованием '>' создаст новый файл или полностью перезапишет содержимое существующего.

Использование '>>' позволяет также создать новый файл при отсутствии и добавить данные в его конец - без полной перезаписи:


$ date >> date.txt
$ cat date.txt
Sat Dec 14 20:50:46 MSK 2024
Sat Dec 14 20:51:40 MSK 2024


Подчеркну, что перенаправляется только STDOUT. Если программа писала ошибки в поток STDERR, они так и выведутся в терминал:


$ find /etc -type f > ~/results.txt
find: ‘/etc/ssl/private’: Permission denied


Давайте дополнительно обработаем и STDERR - для этого нам явно нужно указать номер целевого дескриптора "2>":


$ find /etc -type f > ~/results.txt 2> ~/errors.txt

$ cat ~/errors.txt
find: ‘/etc/ssl/private’: Permission denied


Также бывает полезно подчистить вывод какой-нибудь команды от всех ошибок. Для этого нам нужно перенаправить STDERR в "/dev/null":


$ find /etc -type f 2> /dev/null


Все, что попадает в "/dev/null" исчезает на веки вечные. Такой себе "black hole".

И, наконец, если нужно, чтобы всё попало в один файл, можно перенаправить оба потока в одно и то же место:


$ ls > /tmp/lsdata 2>&1
$ ls &> /tmp/lsdata


Выражение "2>&1" означает «отправлять stderr туда, куда направляется stdout».

🐧 LinuxCamp
Please open Telegram to view this post
VIEW IN TELEGRAM
Зачем процессы туда данные отправляют?

Этот пост является неким анонсом публикации про перенаправление ввода-вывода: >, >>, |. Чтобы понять, как оно работает, следует сначала разобрать потоки данных, в которые перенаправление и происходит.

И так, у каждой программы существует 3 системных потока: stdout, stderr, stdin. Потоки представляют собой сущности для транспорта информации - для простоты пока можно считать их файлами под дескрипторами 0 (in), 1 (out), 2 (err):


$ cd /proc/551981/fd
$ ls
0 1 103 2 43


В примере выше мы зашли в виртуальную директорию процесса 551981 (PID), в которой хранятся дескрипторы открытых файлов. По ним, как раз, происходит чтение и запись информации.

STDIN

Данный поток используется процессом для получения информации извне. Когда мы запрашиваем какой-то ввод от пользователя, данные попадают в stdin, после чего считываются из него программой.

Давайте запустим команду cat:


$ cat
Hello bro
Hello bro


В примере выше cat ожидает от пользователя ввод, который впоследствии считывается с потока stdin (по 0 дескриптору) и направляется в поток stdout для вывода в терминал. Как результат, мы видим дубликат нашего текста.

Никто нам также не запрещает закрыть дескриптор, отвечающий за stdin - в таком случае программа просто не сможет получить данные.

STDOUT

Поток stdout (дескриптор 1) отвечает за вывод информации программой. По умолчанию все, что в него попадает, выводится в терминал:


$ echo $USER
parallels


STDERR

Еще один поток вывода информации (дескриптор 2), который отвечает за отображение ошибок. Если программа не смогла сделать все как надо — она пишет именно в него. Например, когда rm пытается удалить несуществующий файл:


$ rm example.txt
rm: example.txt: No such file or directory


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


$ rm example.txt
rm: example.txt: No such file or directory

$ echo $?
1


Значение 1 говорит о том, что в программе были ошибки, 0 - все хорошо. Такой прием бывает полезен для написания скриптов автоматизации - нам иногда следует понимать, нормально ли прога отработала.

🐧 LinuxCamp
Please open Telegram to view this post
VIEW IN TELEGRAM
Love Center - Dating, Friends & Matches, NY, LA, Dubai, Global
Love Center - Dating, Friends & Matches, NY, LA, Dubai, Global
Find friends or serious relationships easily