Привет. На gnu.org как-то пролетал improvement тикет, который звучит так: Эмоджи/Смайлики не поддерживаются в оболочке bash в качестве имен переменных.

А правда, почему? Что бы отвечать на подобные вопросы, сначала нужно задать другой вопрос — что бы что?

А ответ на этот вопрос простой: Ни одна из оболочек не поддерживает такое. Потому что POSIX не требует от оболочки поддержки символов, отличных от «цифр, букв, символа подчеркивания из набора кодировки (ASCII)». И добавлять поддержку эмоджи/смайлов вообще не имеет никакого смысла.

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

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

Вот пример рабочей функции, которая выводит Hello World.

#!/bin/bash

😀😀😀 () {
 echo "hello world"
}
😀😀😀

Можно прям веселые bash скрипты писать (добавлять какашки и баклажаны) и радовать своих коллег. 💕 Пусть орут.

Пока на этом все, после интеграции от партнера, чего-нибудь еще интересное закину почитать, увидимся!

Ну а если скучно и хочется прокрастинации, камон в мои мемные айти каналы: @devopsina и @devopsgarden

tags: #bash #linux
—
🟢 Подпишись: @bashdays

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

И такой линтер есть, называется shellcheck. С помощью него можно производить статический анализ кода и повышать качество твоих замечательных скриптов. Написан этот линтер на Haskell.

Haskell — стандартизированный чистый функциональный язык программирования общего назначения. Является одним из самых распространённых языков программирования с поддержкой отложенных вычислений.

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

Установка элементарная

apt/yum/brew install shellcheck

А использование этого линтера, вообще максимально простое:

shellcheck script.sh

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

^-- SC1036 (error): '(' is invalid here. Did you forget to escape it?
^-- SC1088 (error): Parsing stopped here. Invalid use of parentheses?

For more information:
  https://www.shellcheck.net/wiki/SC1036 -- '(' is invalid here. Did you forg...
  https://www.shellcheck.net/wiki/SC1088 -- Parsing stopped here. Invalid use...

Что еще сказать, этот линтер можно прикрутить в vim. Достаточно установить из репозитория плагин Plug 'neomake/neomake’. А в VSCode так и называется shellcheck.

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

🐱 Проект shellcheck на github

Ну и котиков лови: 🤭. 👀 😊 кудаж без них.

tags: #bash #utils
—
🟢 Подпишись: @bashdays

Всем доброе утро! По мотивам поста про изучения bash через игры. Мне в бота накидали достаточно много всего. Всем большое и огромное спасибо ребята!

Больше всего раз упоминалась игрушка «Bandit» от Overthewire. Давай обсудим.

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

Устанавливать ничего не надо, заходишь на сайт, выбираешь Level 0 и читаешь условия задачи. Затем подключаешься физически по ssh к серверу и начинаешь игру.

ssh -p 2220 [email protected]

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

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

В общем рекомендую поиграть. Ну а если уперся, можешь глянуть полное прохождение на хабре. Да и на ютубе этого добра навалом.

Помимо «Bandit» на сайте имеется еще с десяток игр, покопайся, обязательно что-то зацепит.

Я в прошлой жизни обожал игру uplink, просто жил в ней. Помню даже отреверсил и патч сделал, чтобы накинуть на баланс денег и купить крутое виртуальное железо. Artmoney почему-то ее никак не хотела ломать, пришлось на ассемблере инжектор писать.

Uplink — компьютерная игра, симулирующая деятельность хакера. Дебютный проект, выпущенный британской независимой компанией Introversion Software в 2001 году

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

У Introversion еще есть несколько крутых игрух, например крутецкая стратегия darwinia. Тоже рекомендую погонять. Ну и defcon. Короче все их игры это шедевры.

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

tags: #linux #games
—
🟢 Подпишись: @bashdays

Хеллоу! Попался мне вчера чей-то очередной bash скрипт, в котором были такие конструкции:

echo '--------------' 
printf '%s\n' '--------------'

Так-то нормальная практика, но смотрится как-то уж очень не профессионально. У python и прочих языков такое можно реализовать примерно так:

python3 -c 'print("-" * 80)'
perl -E 'say "-" x 80'

А что-же с bash? Из коробки такой функции увы нет. Включаем «режим изобретателя». Поехали.

repeat(){
    for i in {1..90}; do echo -n "$1"; done
}

repeat '-'

Создаём функцию с циклом repeat, в которую передадим символ «-» для повторения 90 раз. Вот оно! Уже намного лучше.

Теперь если мне нужно вывести какие-то заголовки в «рамке», я делаю так:

repeat '-';.
echo -e '\nHeader 1\t\tHeader 2\t\tHeader 3\t\t\t\tHeader 4';
repeat '-';

Уже не плохо. Символ \t означает = Табуляция. Ну а \n я думаю ты и так знаешь = Новая строка.

Гуд. Но функция все равно не универсальная, хочется большего. Давай теперь передадим в функцию repeat количество повторов. В предыдущем скрипте у меня зашит харкод на 90 символов. Вуаля:

repeat() {
    range=$(seq $2)
    for i in $range; do echo -n "$1"; done
}

repeat '-' 20

Передаем в функцию 2 параметра, первый = какой символ loop’ить, второй = сколько будет повторов. В примере выше, символ «-» выведется 20 раз.

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

# seq 5
1
2
3
4
5

# seq -s : 5
1:2:3:4:5

С этим ок, разобрались. А что если воспользоваться printf? Давай попробуем.

С printf это реализуется намного проще, вот варианты:

printf -- '-%.0s' 1 2 3 4 5
printf -- '-%.0s' {1..20}

Разборка этой магии

Двойное тире означает «флаги командной строки». Поскольку мне нужно вывести «-», двойное тире указывает команде printf не пытаться анализировать то, что идет после параметров командной строки. 😶 ЧО?

Короче простым языком: если выводишь символ «-» через printf, то нужно двойное тире. Если выводишь к примеру символ «~» можно обойтись такой конструкцией:

printf '~%.0s' {1..20}; printf '\n'

Просто при выводе «-» printf думает что ты ему какой-то ключ хотел подсунуть и заорет: printf: -%: invalid option. В общем такая вот особенность. Ну либо всех обмануть и сделать так:

printf '%.0s-' {1..80}

Подобное можно реализовать с помощью внешних утилит таких как: awk/sed и т.п. Но чем больше ты усложняешь, тем тяжелее это дебажить. Это утверждение справедливо вообще для всего.

на закуску:

seq -s_ 20|tr -d '[:digit:]'

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

tags: #bash
—
🟢 Подпишись: @bashdays

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

Для чего вообще нужен временный адрес электронной почты? Лично мне он нужен для регистрации в сервисах, которые предварительно требуют проверки прежде чем я начну с ними работу. Сначала хочу убедиться, что сервис мне подойдет и будет отвечать моим требованиям. А лишь потом регистрироваться в нем на корпоративную почту.

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

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

Можно конечно завести под это дело отдельный почтовый ящик, либо использовать конструкцию [email protected] (подставлять символ «+»), но мне гораздо удобнее получить временный почтовый ящик консольной командой и принять на него письмо. Сейчас расскажу как такое реализовать.

Будем использовать готовый bash скрипт

wget -O /usr/local/sbin/tmpmail https://raw.githubusercontent.com/sdushantha/tmpmail/master/tmpmail

chmod +x /usr/local/sbin/tmpmail

Выкачиваем, помещаем в папку /usr/local/sbin и даем файлу атрибут на исполнение.

Обязательно пробегаемся глазами по скаченному файлу, чтобы в нем не было приколов типа «Патча Бармина»

Ок, Запускаем

# tmpmail
Could not find the following dependencies: jq w3m xclip curl

Хм, устанавливаем зависимости:

apt/yum/brew install jq w3m xclip curl

Ну и запускаем повторно:

# tmpmail
[ Inbox for [email protected] ]

No new mail

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

ВАЖНО! Отправлять письма с таких ящиков ты не можешь, они работают только на приём.

У скрипта есть несколько ключей, давай посмотрим:

Сгенерировать НОВЫЙ временный адрес

# tmpmail -g
# tmpmail -g [ADDRESS]

Если указать [ADDRESS], то временная почта будет с твоим индивидуальным префиксом. Ну а если не указывать, то будет рандом.

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

# tmpmail -d
# tmpmail -g [email protected]

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

Из основного это всё. Ну а чтобы посмотреть список входящих писем. Просто запускаешь заново:

# tmpmail
[ Inbox for [email protected] ]
- 347359684 [email protected] Signup code for Workflowy

Для того чтобы прочитать:

# tmpmail 347359684

То есть передаешь идентификатор письма, которое нужно открыть. Либо можешь воспользоваться ключом tmpmail -r, тогда сразу откроется самое последнее письмо.

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

tmpmail -t -r

Ключ -t открывает письмо в raw (сыром) виде. Если этот ключ не указывать, то письмо будет рендериться как HTML. Мне проще сразу открыть последнее и получить текст.

Эту утилиту вполне реально интегрировать со своими bash скриптами и полностью автоматизировать какую-то рутину. Например, если ты QA, то можешь в автотесты легко это закинуть и проверять кейсы про авторизацию и регистрацию новых пользователей. Тут полёт фантазии безграничный.

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

🐱 Проект на github

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

Забирай в коллекцию, рекомендую! 🐾

tags: #services #bash
—
🟢 Подпишись: @bashdays

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

Называется putsbox, про него мало кто знает, он распространен больше в англоязычном сегменте.

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

Из плюсов:
1. Можешь создать одновременно много ящиков
2. Легкая интеграция с Selenium, Capybara и др.
3. Личный кабинет после регистрации (не обязательно)
4. Доступ к ящику по прямой ссылке (можно шарить)
5. В любой момент можно уничтожить временную почту

Входящее письмо открывается как text/html/json. За json прям отдельный респект, можно сразу на бекенде его обрабатывать в тех же автотестах. Вот небольшой мануал как приручить к тестам.

А еще у них есть очень крутой инструмент PutsReq который позволяет дебажить HTTP-запросы и отдавать фейковые ответы.

Собственно на этом всё, Давай, хорошего понедельника!

tags: #services
—
🟢 Подпишись: @bashdays

Хаа.. Привет! Сегодня будем извлекать расширение и имя файла на bash. Для чего? А почему бы и нет! На самом деле это нужно знать, это база. Я часто вижу как это делают люди с помощью какой-то зиготы 🤒 (регулярки/awk/sed), ну боль же. Не надо ничего усложнять, есть вещи на порядок выше.

Что такое имя файла и расширение, объяснять не буду, как говорил мой техдир — заебал, если интересно, сходи погугли.

Теперь по делу. Берем какой-нибудь подопытный файл, пусть будет: bashdays.gzip и накидываем скрипт.

#!/bin/bash

FILE="bashdays.gzip"

FIRST="${FILE%.*}"
SECOND="${FILE##*.}"

echo $FIRST
echo $SECOND

В переменной FILE заносим имя файла bashdays с расширением gzip. Далее в переменной FIRST отсекаем расширение gzip, в переменной SECOND отсекаем имя bashdays. По итогу на экран выведется такая шляпа:

bashdays
gzip

Понял? Легкотня, без гигантских регулярок и гавнокода. Сейчас объясню подробнее, что происходит.

Символ %.* означает отсекание всего после точки.
Символ ##*. ну а тут наоборот, отсекание всего до точки.

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

FIRST="${FILE%,*}"
SECOND="${FILE##*,}"

Проще уже не объяснишь. Если не дошло, сам потыкай на примерах и уже точно въедешь в тему, на практике само собой всё проще и понятнее.

Это один из способов реализовать желаемое. Но есть и другой. Давай воспользуется командой basename.

Команда basename в Linux печатает последний компонент в пути к файлу. Это особенно полезно в скриптах bash, где вы хотите извлечь имя файла из длинного пути к файлу.

Если тебе заранее известно расширение файла, в нашем случае оно известно как gzip. То мы сможем отсечь расширение такими способами (они идентичны):

basename /tmp/bashdays.gzip .gzip
basename -s .gzip /tmp/bashdays.gzip

В обоих случаях на экран выведется: bashdays

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

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

С basename вроде всё, дальше у нас по списку dirname.

Команда dirname в Linux печатает путь к файлу с удаленным последним компонентом. Это в основном дает вам путь к каталогу из пути к файлу.

dirname /usr/local/sbin
dirname /tmp/bashdays.gzip
dirname /usr/bin/date

Результат будет таким:

/usr/local/
/tmp/
/usr/bin/

Ну а чо, вообще шикарно! Ну и вишня для гиков, магия с переменной $IFS.

Переменная IFS (внутренний разделитель полей) используется для указания определенного разделителя для разделения строк.

_file="/tmp/bashdays.gzip"

OLDIFS="$IFS"
IFS='.'
set -- $_file
IFS="$OLDIFS"

printf "File: %s\nExt: %s\n" "$1" "$2"

Кратенько: Определяем имя файла, задаем переменную IFS для извлечения имени файла и расширения, указываем разделитель «.» (точка), выполняем set для разделения на позиционные параметры, ну и выводим все на экран с помощью printf (но можно и через echo).

Выхлоп скрипта будет таким:

File: /tmp/bashdays
Ext: gzip

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

Уффф.. Как-то много букв получилось, пардон. Основные моменты рассмотрели, надеюсь твой интерес я удовлетворил. Спасибо за внимание, ставь лайк. А вечером закину еще что-нибудь занимательное. Давай, на связи!

tags: #bash #linux
—
🟢 Подпишись: @bashdays

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

Как проверить, определена ли переменная в bash скрипте? Давай разберемся.

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

Чтобы узнать определена ли переменная я могу передать параметр -z условному выражению if.

if [ -z ${CRAZYDAY+x} ];
then
    echo "LOGIC 1"
else
    echo "LOGIC 2"
fi

либо с помощью команды test

if test -z ${CRAZYDAY+y}
then
    echo "LOGIC 1"
else
    echo "LOGIC 2"
fi

Команда test применяется для проверки условия. Она вычисляет выражение и, если его значение - истина, возвращает код завершения 0; иначе - ненулевое значение. Ненулевой код возвращается и в случае, когда выражение отсутствует. При проверке прав доступа используется действующий идентификатор пользователя.

Когда я запущу эти скрипты, не установив переменную CRAZYDAY, я получу результат LOGIC 1. Для того что бы получить LOGIC 2, я должен сделать:

export CRAZYDAY=somestr
./script.sh

Результатом будет LOGIC 2. Чтобы снова получить LOGIC 1, мне нужно сбросить установленную переменную с помощью команды: unset CRAZYDAY.

Теперь давай разберем как работает: ${CRAZYDAY+x}

Выполняем последовательно команды и смотрим на выхлоп дебага:

set -x
./script.sh

вернуло:

+ '[' -z ']'
+ echo LOGIC 1
LOGIC 1

далее:

CRAZYDAY=some ./script.sh

появился параметр x, с ним и идет сравнение, x=some

+ '[' -z x ']'
+ echo LOGIC 2
LOGIC 2

далее:

export CRAZYDAY=str
./script.sh

вернуло то же самое

+ '[' -z x ']'
+ echo LOGIC 2
LOGIC 2

ну а теперь так:

unset CRAZYDAY
./script.sh

вернуло тоже самое как и в первом примере

+ '[' -z ']'
+ echo LOGIC 1
LOGIC 1

По сути x это расширение параметра bash, если переменная CRAZYDAY не задана, она не имеет в себе никакого значения. Ну а если задано, то все что внутри переменной CRAZYDAY заменяется просто на x и потом уже сравнивается в if.

Вместо x можно написать хоть что, будет работать. Но в бест практиках рекомендуют использовать именно x ну или y.

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

set -x = включить режим дебага
set +x = выключить режим дебага

Добавить пока больше нечего, изучай. Завтра снова увидимся, очередной CRAZYDAY. Ну и доброй ночи тебе!

tags: #bash #linux
—
🟢 Подпишись: @bashdays

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

Сделать это можно несколькими способами:

filename="test.txt"

if [ -f $filename ];
then
    echo "File exist"
fi

if test -f $filename;
then
   echo "File exist"
fi

В первом примере ключ -f означает = True if file exists and is a regular file. Возвращаем True если файл существует и является обычным файлом (не директорий, ни симлинком и т.п.)

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

Команда test предназначена для проверки типа файла и сравнения чисел и строк. Возвращает код возврата 0 (истина) или 1 (ложь) в зависимости от вычисления выражения. Выражения могут быть как унарными, так и бинарными.

Ну а если подставить символ «!» в условия, то сработает обратная логика:

if [ ! -f $filename ];
if ! test -f $filename;

Здесь мы уже получим сообщение — указанный файл не найден. Для разных задач, разные условия.

Да, часто возникают вопросы по ключу «-f», это не единственный ключ, их достаточно много, например можно проверить существование директории, сокета, установленные права и т.п. Табличку со всеми этими ключами я вынес отдельно сюда.

То же самое можно уместить в одну строчку, синтаксис будет таким:

[ ! -f "$filename" ] && echo "file not found" || echo "file exist"

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

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

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

tags: #bash #linux
—
🟢 Подпишись: @bashdays

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

Задача: нужно чтобы скрипт отработал 3 минуты и завершился.

Можно конечно запустить скрипт, подождать 3 минуты и руками его стопнуть через ctrl+c, но это не трувей. А что если нужно 5 минут или 45? Не буду же я сидеть всё это время в ожидании.

К счастью у нас с тобой есть утилита timeout, которая уже идет в коробке с Linux.

Timeout, это утилита командной строки, которая запускает указанную команду и завершает ее, если она все еще выполняется через определенный промежуток времени. Другими словами, timeout позволяет запустить команду с ограничением по времени. Команда timeout является частью пакета основных утилит GNU, который устанавливается практически в любом дистрибутиве Linux.

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

timeout 3s ping www.bashdayz.ru

Команда ping отработает 3 секунды и завершится. Конечно у ping есть свои ключи для этого, но сегодня у нас про другое.

Синтаксис у команды timeout довольно простой:

timeout DURATION COMMAND

DURATION = Длительность. Это число с плавающей запятой и с необязательным суфиксом следующего вида:

s = секунды
m = минуты
h = часы
d = дни

COMMAND = сама команда или скрипт, которому нужно ограничить работу по времени.

Допустим мне нужно запустить какое-то приложение (например top) на удалённом сервере и через 3 минуты всё это безобразие прекратить. Ок, делаем такое:

timeout 3m ssh [email protected] -- /usr/bin/top

Прошло 3 минуты, приложение гасится, ssh сессия завершается. Удобно? Удобно!

Если по истечению этого времени у тебя в терминале исчез курсор (частенько такое бывает), то выполни команду reset, терминал сбросится и всё вернется на круги своя.

Так же можно послать определенный сигнал завершения для приложения. К примеру:

timeout -s 9 3m ping www.bashdayz.ru

Чтобы получить список всех сигналов, можешь выполнить команду kill -l и посмотреть. Их там достаточно много. Я не заморачиваюсь и рублю с плеча сигналом 9 (SIGKILL). Убивать так убивать.

Вместо номера сигнала, можно указывать явное имя:

timeout -s SIGTERM 5m ping www.bashdayz.ru

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

Ладно. Утилита timeout это клева, а как реализовать то же самое не применяя ее, на чистом bash’е? Смотри:

ping www.bashdayz.ru & read -t 3 || kill $!

В этом примере выполняется ping и по прошествию 3х секунд завершается. Тут уже тебе самому решать, использовать timeout либо подобную конструкцию.

А, точно, забыл объяснить про символ «$!». Эта конструкция содержит в себе идентификатор процесса (PID) последнего выполненного фонового конвейера. В примере выше последним выполненным заданием был ping. То есть явно не нужно указывать PID, чтобы kill корректно отработал.

Собственно на этом всё. В Linux столько всего интересного, но не каждый про это интересное знает. Я изначально использовал bash конструкцию и только спустя какое-то время узнал про утилиту timeout. Век живи, век учись. 😐 Котиков тебе и удачи. Давай, увидимся!

tags: #bash #utils #linux
—
🟢 Подпишись: @bashdays

Привет, коллеги. Ура, чтиво подвезли! Есть такая команда в Linux, называется cat. Ну ты наверняка про неё знаешь.

С помощью cat можно быстро посмотреть содержимое файла, объединить несколько файлов в один, ну и так далее.

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

bat — это продвинутый клон cat с поддержкой подсветки синтаксиса и интеграцией Git.

Утилита bat поддерживает подсветку синтаксиса для огромного количества языков программирования. Выводит текст в читаемом виде и нумерацией строк. Сделано всё это для того, чтобы ты лучше воспринимал информацию, которая выводится на экран.

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

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

Установка стандартная

apt/yum/brew install bat

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

alias bat="batcat"
mkdir -p ~/.local/bin
ln -s /usr/bin/batcat ~/.local/bin/bat

Как пользоваться? Элементарно:

bat ~/bashdays.sh

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

Если нужно вывести диапазон строк, делаешь так:

bat -r 20:25 ~/bashdays.sh

Если ты новичок и не знаешь что такое «~/», это домашний каталог, допустим ты работаешь под пользователем user, и выполнив cd ~ ты попадешь в жопу в /home/user. Посмеялись, поехали дальше.

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

bat -L

Основное рассмотрели, у bat есть еще куча разных ключей, если есть интерес запускай: bat --help и наслаждайся. Многое можно включить и отключить.

Я использую bat из коробки, без всяких ключей, чисто на просмотр файлов, остальное мне и не нужно.

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

Больше подробностей можешь найти на 🐱 официальной github странице. Там же можешь посмотреть картинки как это всё выглядит в реальном времени, в этот пост опять ничего не могу вставить, ограничения по символам.

Лады, рад был тебя видеть. Увидимся наверное завтра.

tags: #utils #linux
—
🟢 Подпишись: @bashdays

Ты всяко слышал или используешь Ansible/Puppet/Chef для размножения своего хозяйства. Молодец! Инфраструктура как код — мастхев, но при условии, что код не превращен в кусок спутавшихся спагетти. Как показывает практика, в 99.9% случаев IaC = IaG (Infrastructure-as-Govno).

Ладно, сегодня разговор не про это, сегодня поговорим про то же самое, но сбоку. Ведь одну задачу можно решать разными способами. И сегодня на повестке у нас с тобой маленький и изящный инструмент под названием Parallel ssh (PSSH).

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

После установки pssh, в комплекте ставятся еще такие утилиты: pscp, prsync, pnuke, pslurp. То есть из коробки у тебя еще есть 4 инструмента чтобы параллелить свои джобы под разные задачи.

Установка стандартная: apt/yum/brew install pssh

После установки, можешь посмотреть что прилетело в этом пакете: dpkg -L pssh | grep bin



parallel-nuke, parallel-rsync, parallel-scp, parallel-slurp, parallel-ssh

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

Генерим ключик: ssh-keygen

Закидываем ключики на хосты с помощью команды, либо переносим ручками:

ssh-copy-id [email protected]
ssh-copy-id [email protected]

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

Давай теперь рассмотрим как всем этим добром пользоваться.

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

vim ~/.pssh_hosts_1

и добавить в него к примеру такое:

[email protected]
[email protected]

Теперь можно запускать!

parallel-ssh -i -h ~/.pssh_hosts_1 uptime

Опа! Работает! Утилитка сходила на 2 моих сервера и притащила аптайм. Как ты заметил я запускаю parallel-ssh а не pssh. Чтобы запускать эти утилиты с коротким именем, нужно создать симлинки или алиасы. Это не критично, больше для удобства. Я голову не грею и запускаю с длинным именем.

У тебя могут быть несколько файлов .pssh_stage/prod/test, допустим для прода, стейджа и тестов, тут сам уже этим наруливаешь и при запуске указываешь какой файл инвентаря использовать через ключ -h. Ну а ключ -i выводит данные на экран.

Давай апдейтним пакеты:

parallel-ssh -h ~/.pssh_hosts_1 -- apt -y update

Флаг разделитель «--» означает, что команда pssh завершена и запущена новая команда. В этом случае разделитель указывает оболочке, что не нужно пытаться анализировать, то что следует после параметров командной строки. Эту тему рассмотрим в отдельном посте.

Остальные утилиты pscp, prsync, pnuke, pslurp, делают то же самое что и их собратья, синтаксис аналогичный. К примеру для копирования файла на несколько серверов делаем так:

parallel-scp -h ~/.pssh_hosts_1 /tmp/bs.txt /tmp

Аналогично поступаем и с другими утилитами из этого пакета:

pnuke = завершить процессы
pslurp = скачать файлы с удаленных хостов
prsync = мощнейшая штука для синка файлов туда-сюда

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

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

Конечно Ansible/Puppet/Chef никто не отменял, но с помощью пакета pssh, ты сможешь изобрести что-то своё и главное тебе понятное.

Кстати в природе существует еще pdsh (parallel distributed shell). Но я предпочитаю именно пакет pssh, так как он включает в себя еще 4 нужные мне софтины.

Основное рассмотрели. Похоже пора перечитать книгу «пиши сокращай», но блин из песни слов не выкинешь. Пардон за простыню, но инфа полезная. Хорошего тебе дня!

tags: #utils #linux
—
💩 @bashdays

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

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

ssh [email protected] --

Ты наверняка встречал такое и даже применял бездумно, но что означает это двойное тире? Зачем оно? Сейчас покажу на котиках.

Двойное тире означает «флаги командной строки». Оно указывает ssh или другой команде не пытаться анализировать то, что следует после параметров.

Масло масленное. Погнали на практике покажу, теория нам не интересна!

У меня есть такая команда:

ssh [email protected] -- command1 --arg1 --arg2

Приведенный выше синтаксис указывает ssh не пытаться анализировать параметры arg1 и arg2 после символа «--». Это гарантирует, что команда command1 примет arg1 и arg2 в качестве аргументов командной строки и выполнится на удаленном сервере.

Короче говоря мы сообщаем ssh - все то, что идет после двойного тире, это не твои параметры и аргументы, анализировать это НЕ НАДО! СТОП! Дальше дело за command1 и его параметрами и аргументами.

Двойное тире обрабатывается нифига не оболочками bash/zsh/csh/sh/fish и т.п. Оно обрабатывается средствами самих программ, но НЕ всех. Например ssh это умеет делать, как и множество других команд и утилит.

Рассмотрим другие примеры. Например, ты не сможешь просмотреть файл с именем --file или -f используя команду cat. Проверяем:

cat --file
cat -f

Опа. Ошибка! cat: unrecognized option --file/f. Давай теперь передадим двойное тире:

cat -- --file
cat -- -f

Еее! Ошибка пропала и файл успешно вывелся на экран, ну либо выскочило сообщение cat: --file/f: No such file or directory. Это нормально.

Закрепим:

rm --file       = получим ошибку
rm -- '--file'  = а вот это сработает

Ну а что бы передать параметры в rm, делаем так:

rm -v -i -- '--file'
rm -f -v -i -- '-f'

Просто, логично, мелодично. Но как я и сказал выше, не все команды умеют работать с двойным тире. Например, команда echo, на все попытки подружить её с двойным тире, просто-напросто провалятся:

/usr/bin/echo -- -n
echo -- --test

выведется это:

-- -n
-- --test

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


tags: #bash
—
💩 @bashdays

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

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

К примеру мой вело-скрипт для бэкапов основан на команде tar и в какой-то момент оно начало возвращать ошибку. Бэкапы соответственно перестали делаться, но я про это ничего не знаю. Но добавив в скрипт обработку ошибок, я получил неплохой триггер, который в случае факапа накричит мне в телеграм. А я успешно это прочитаю и забью болт 📺 рабочие будни.

Статус выхода, это целое число от 0-255, где 0 это успешное завершение команды/программы. Все остальные коды, это ошибки.

Например, если программа не найдена ни в одном из путей $PATH либо ее вообще нет в системе, то оболочка вернет 127 код ошибки. Ну а если команда/программа найдена, но не является исполняемой, то мы получим код 126 (Permission denied).

Чтобы сделать программу/скрипт исполняемым, ставь специальный аттрибут: chmod +x <program/script>

Как отловить код выхода из программы/скрипта

Все очень просто, существует специальная зарезервированная переменная «$?», которая будет хранить в себе как раз тот самый код выхода. Теперь наглядно, запускаем:

# date
# echo $?
0

Видим что прилетел 0, окей, команда отработала успешно. Теперь запустим так:

# bashdays
# echo $?
127

Как видим вернулся код 127, как я писал выше, этот код означает, что не удалось найти программу с именем bashdays.

Понятно? Думаю вообще все прозрачно. Имея эту информацию, можно строить гибкую логику в скриптах и обрабатывать эксепшены.

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

#/bin/bash

date
code=$?
echo "exit code : ${code}"

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

Рассмотрим ситуацию с логикой:

#!/bin/bash

date
code=$?

if test $code -eq 0
then
  echo "success"
else
  echo "failed"
fi

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

Если команда date вернет 0 (-eq - означает равно), скрипт завершится со статусом 0 = success, во всех других статусах мы получим failed.

Так же ты можешь самостоятельно возвращать нужные тебе коды в своих скриптах. Я использую этот способ в пайплайнах, когда gitlab считает что завершил сборку успехом, но на самом деле это не так. Подкидываешь ему exit 1 и пайплайн уже не зеленый, а красный.

Рассмотрим пример:

#!/bin/bash

date
time
exit 1
echo "hello"

После запуска, выполнятся две команды date и time, затем всё завершится с кодом 1 не передав управление команде echo.

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

Тема вроде очень простая, но всегда вызывает вопросы и недоумение — В смысле код ошибки? Какой еще 🤒 ошибки? А что так можно было?

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

Давай краба, завтра увидимся, хорошо тебе догулять выходные!

tags: #bash
—
💩 @bashdays

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

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

Смотрим mysql ошибки:

tail -n 20 /var/log/mysql/error.log

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

Ключ -n = количество строк с конца, которые выведутся на экран, по умолчанию 10.

Так, получили 20 строчек с ошибками, смотрим что же там, опа ошибка:

11:47:52 [ERROR] mysqld: Can't open file: ‘/var/lib/mysql/tokens.frm' (errno: 24)

О чем она мне говорит? Ну ясно понятно - не могу открыть файл tokens.frm. Идем смотреть, хм, файл лежит на месте и даже не нулевого размера. Права правильные mysql:mysql. Так… место на диске тоже предостаточно. И что ты от меня хочешь псина?

Важный совет — всегда читай ошибку с начала и до конца! В 99% ты сможешь понять о чем идет речь и загуглить. Но как показывает практика: много кто читает 2-3 слова и бежит к тимлиду — Наташа, у нас все сломалось! А Наташа смотрит тот же самый лог и прекрасно понимает в чем дело. Не беси своего тимлида! Читай внимательно, вникай.

Вернемся к нашей неочевидной ошибке с открытием файла tokens.frm. Видишь в конце строки, в скобочках errno: 24? ВОТ ЭТО ОНО! А что значит 24? Ща…

Из коробки с mysql идет прекрасная утилита, которая называется perror, вот с помощью нее ты и можешь расшифровать эту ошибку. Давай попробуем.

perror 24
OS error code  24:  Too many open files

Ёпта! Too many open files, а мы то всего-навсего уперлись в open_files_limit который прописан в конфиге my.cnf. Дело закрыто! Увеличиваем этот параметр и гордимся своими профессиональными навыками дебагинга.

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

Еще есть прекрасный файл /etc/security/limits.conf в котором тоже может быть что-то не так накручено, ну и параметр fs.file-max в /etc/sysctl.conf. Каждая отдельная ситуация индивидуальна. Но в большинстве случаев решается повышением значения ulimit.

Для каждого кода ошибки в mysql будет свой способ решения, чем больше у тебя информации на руках, тем больше запросов ты сможешь загуглить. Так что если что-то упало, не рви на жопе себе волосы, всё решаемо и ты обязательно справишься! Главное знать какой инструмент и когда применить.

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

tags: #mysql #linux #debug
—
💩 @bashdays

Про офигительные циркули. Порой бывает устанавливаешь какую нибудь софтину на linux, а впридачу с ней идет огромный example конфиг. Этим конфигом можно пользоваться по дефолту, либо тонко настраивать. Например, конфиг от php.ini весит 80 килобайт. И больше половины в этом конфиге - комментарии и шляпа.

А хочется сделать из этого конфига простенький шаблон например для ansible, но без лишнего мусора. Чтобы было основное, что позволит софтине вообще запуститься (пути, логи, сокеты и т.п.). Руками выкашивать 60-70 килобайт, то еще занятие.

Но что если сделать свой собственный маленький парсер? Который выкосит все ненужное и оставит необходимый минимум. Да, прям на bash! Погнали зажигать!

Для примера будем работать с тем же файлом php.ini и приведем его в юзер-френдли вид.

Накидываем скрипт:

#!/bin/bash

sep=$2

while IFS= read -r var
do
  [[ $var =~ ^$sep.* ]] || [[ ! $var =~ ' ' ]] && continue
  echo "$var" >> $1.tpl
done < $1

Запускаем так:

./script.sh php.ini ";"

Передаем 2 параметра. Первый = имя файла-конфига, который будем читать и парсить. Второй = символ, которым комментируются строки в этом файле.

В моем случае комментарии в файле идут после «;» символа. Обращаем внимание, что второй параметр передаем в кавычках. Если передать напрямую, то оболочка bash не поймёт что от нее хотят и выпадет в panic.

Разбираем скрипт:

Присваиваем переменной sep, символ, который передали вторым параметром $2. У меня это символ «;».

Далее идет цикл, который построчно читает файл php.ini переданный в первом параметре $1 при запуске скрипта. Тут универсально, можешь любой файл передать, скрипт его сам схавает как нужно.

IFS= разделяет строку с использованием символа в качестве значения

Ну и логика цикла:

Если первый символ равен символу «;», который уже лежит в переменной sep ИЛИ первый символ равен пустой строке, ТО передаем управление команде continue, которая проигнорирует запись в output файл. И так по кругу, пока не закончится файл.

Команда continue пропускает оставшиеся команды внутри тела цикла для текущей итерации и передает управление программой к следующей итерации цикла.

Символ || означает = ИЛИ

ВО ВСЕХ ДРУГИХ СЛУЧАЯХ, происходит запись в output файл, в котором будут содержаться только необходимые для работы параметры.

На выходе получится 2х килобайтный файл php.ini.tpl, без комментариев и прочего шлака. Чистый как слеза.

80 килобайт vs 2 килобайта! Ха! Разница ощутима, теперь можно сделать шаблончик для ansible/puppet/chef.

В своем скрипте я использую простые регулярные выражения. ДА! В bash это можно делать через символы «=~».

$var =~ ^$sep.*

^ = соответствует началу текстовой строки
$sep = символ с помощью которого комментируют строки
.* = оставшийся кусок строки

А можно еще другим способом определять начинается ли строка с определенного символа. Но конкретно с разделителями «;»/«#» это будет работать не корректно.

[[ $var = Y* ]] && echo "String start with Y"

В примере выше, происходит проверка, является ли первый символ в строке символом «Y» и если да, то пезда, выводится соответствующее сообщение. Регулярок тут нет, чисто «*» правит балом.

Такие дела. И без применения всяких sed/бред/винегрет. Нативно, на bash, даже с регулярками научились взаимодействовать, а регулярки развязывают на многое руки. В пределах разумного, не нужно brainfuck создавать.

Brainfuck — один из эзотерических языков программирования, придуман Урбаном Мюллером

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

Завтра сделаем паузу, а в четверг и в пятницу еще немного поэкспериментируем. Давай! Пока-пока!

tags: #bash
—
💩 @bashdays

В Linux есть масса утилит, для поиска файлов. К примеру всем известный монструозный find, который умеет даже тапочки приносить.

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

И это решение, утилита locate.

Утилита locate используется для поиска файлов, расположенных на машине пользователя или на сервере. Фактически она выполняет ту же работу, что и команда find, однако, ведёт поиск в собственной базе данных.

Ключевая фраза здесь - в собственной базе данных. То есть применяя утилиту locate, поиск файлов будет осуществляться не по файловой системе, как это делает find. А будет использоваться собственная база данных. Коротая позволяет искать файлы со скоростью света.

Обновление базы данных locate происходит автоматически, как правило, раз в сутки. Либо можно запустить руками командой updatedb.

Давай теперь потыкаем, запускай:

locate txt

Ищем все файлы, имена которых содержат «txt». Опа, меньше чем за секунду команда нашла все подходящие файлы, которые можно было найти. А если сделать это через find, то это у меня это заняло 18 секунд. Разница очень ощутимая.

Ищем файлы, которые оканчиваются на «txt»

locate '*txt' 

А теперь давай посчитаем общее количество файлов, которые нашлись

locate -ic '*txt' 

Ключ -i = режим регистронезависимости
Ключ -с = вывести общее количество найденных файлов

Полезли в кишки, заводим strace.

Переходим в папку cd /tmp и создаем подопытный файл: > hello.txt

Знал же что пустой файл можно создать через символ «>»? Если нет, то теперь знаешь.

Так, я нахожусь в папке tmp и у меня создан файл hello.txt запускаю:

locate *txt

Опа, ничего нет, как так? Мы же уже запускали ранее это, чтобы найти все файлы, которые заканчиваются на txt. Что случилось?

Мы вызываем внешнюю команду locate, но вызываем мы ее из интерпретатора bash. Вернее её вызывает сам интерпретатор. И это накладывает свои нюансы. В нашем случае этот нюанс «Подстановка имен файлов», то есть Globbing.

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

Во времена UNIX V6, существовала программа /etc/glob, которая могла раскрывать шаблоны подстановки. Очень скоро она стала встроенной функцией командной оболочки.

Но что же случилось то в итоге, почему ничего не нашлось? А произошло следующее: после того, как интерпретатор обнаружил символ «*», который является спецсимволом и соответствует любой строке, интерпретатор попытался сделать подстановку Globbing и ему это удалось.

И при вызове команды locate она получила в качестве аргументов, результат этих подстановок. Давай посмотрим наглядно что произошло. Запускаем:

strace -e execve locate *txt 

На выходе получаем:

execve("/usr/bin/locate", ["locate", "hello.txt"], 0x7ffe242252d8 /* 27 vars */) = 0

Опция «e» и аргумент «execve» сообщают strace, что я хочу отслеживать только системные вызовы «execve».

execve() выполняет программу, заданную параметром filename

Возвращаемся к выводу от strace и видим что locate получила в качестве аргумента hello.txt

И теперь locate будет искать файлы именно по этому шаблону, а не по тому, что мы с тобой ожидали, когда писали «*txt».

Вот лишь по этому на экран ничего не вывелось, когда я запустил locate *txt

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

locate '*txt' 

Механизм подстановки имен файлов (Globbing) на самом деле удобен, просто нужно использовать его по назначению.

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

Поигрались и хватит. Пошли дальше работу работать. Всех был рад видеть, пока-пока!

tags: #bash #strace #debug
—
💩 @bashdays

Здарова! У меня на машине имеется пачка всяких alias’ов для продуктивной работы. К примеру есть такой alias cat='batcat’.

Я привязал команду cat к нужной мне утилите. В данном случае это batcat. Про нее я рассказывал в предыдущих постах.

Все работает отлично, но что мне делать когда требуется деактивировать этот alias и воспользоваться чистой командой cat?

Ты скажешь - дак залезь в файл ~/.bashrc/.zshrc да закомментируй всю эту срамоту. Справедливо! Но это какое-то топоровое решение.

Есть несколько вариантов как это осуществить нативно и красиво. Ща покажу.

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

Первый вариант

Перед командой ставим символ «\»:

# \cat /tmp/test.txt

И всё! Теперь в моем случае alias с batcat проигнорирован и сработала нативная утилита cat. Красота!

Второй вариант

Помещаем команду в кавычки, хоть в двойные хоть в одинарные:

# 'cat' /tmp/test.txt
# "cat" /tmp/test.txt

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

Третий вариант

Капитанский вариант с указанием полного пути к команде:

# /usr/bin/cat /tmp/test.txt

Ну тут всё логично, я четко указал что и откуда запускать. Алиасы в пролете. Нативочка в профите.

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

whereis cat
which cat
type -a cat

Четвертый вариант

С помощью команды command

# command cat /tmp/test.txt

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

Пятый вариант

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

# unalias cat

Хаба-хаба и всё! Теперь у нас в текущей сессии чистый cat, без хвостатых мышек сюси.

А чтобы вообще дропнуть все алиасы в текущей сессии, запускай такое:

# unalias -a

Ну вот и все, теперь вообще никаких alias’ов нет, голый король. Ну а чтобы не перезапускать сессию и восстановить как было, делаем так:

source ~/.bashrc
source ~/.zshrc

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

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

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

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

tags: #bash #linux
—
💩 @bashdays

Привет коллега! Надеюсь ты выжил после выходных и не сорвал спину на мероприятии по копке картофеля. Сегодня у нас с тобой bash.

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

Конечно есть, сейчас про это и поговорим. Покажу два способа как это можно легко осуществить. Первый способ основан на символе &.

Пишем подопытный скрипт:

#!/bin/bash

sleep 5 && echo "sleep 5_1" &
sleep 5 && echo "sleep 5_2" &
wait
echo "sleep 0"

Здесь первая и вторая команда запустятся параллельно. Через 5 секунд на экран выведутся 3 строчки sleep 5_1, sleep 5_2 и sleep 0.

Wait – команда, которая ожидает завершения определенного процесса, а затем возвращает его состояние завершения.

Оболочка ждет (wait) пока завершатся два предыдущих процесса, прежде чем запустить следующую команду. Получается, все то, что в скрипте идет после wait, будет в режиме ожидания, пока не завершится первый sleep и второй.

Прикольно да? Открываются новые возможности для совершенствования своих костылей. Прям терпко попахивает асинхронностью, в хорошем смысле. Про wait поговорим в отдельном посте, есть там свои клевые фичи.

Теперь давай запустим в терминале последовательно такие команды:

sleep 60 &
sleep 90 &
sleep 120 &

На экран выведутся записи вроде таких:

[1] 38161
[2] 38166
[3] 38167

Это PID процессов которые ты запустил в фоновом режиме. Но интересует нас тут другое. А именно команда jobs.

Команда jobs в Linux позволяет пользователю напрямую взаимодействовать с процессами в текущей оболочке. Команда отображает состояние заданий в текущем сеансе.

Запускаем jobs и смотрим:

[1]   Done    sleep 60
[2]-  Running sleep 90 &
[3]+  Running sleep 120 &

Опа! А это список команд, которые мы запустили в фоне. Первое задание завершилось, остальное еще шуршит. Некий мониторинг из коробки.

Давай теперь напишем более наглядный пример, где всё это можно применить.

downloader(){
  wget -q "$1"
}
 
while IFS= read -r url
do
     downloader "$url" &
done < urls.txt
 
wait
echo "Downloaded complete"

1. Скрипт читает построчно файл url.txt
2. Передает каждую строчку в функцию downloader
3. Функция downloader каждый раз запускается в фоне
4. Происходит скачивание файла по ссылке
5. По завершению (wait) получаем компливит complete

Файл url.txt представляет собой список прямых урлов на файлы, которые нужно скачать.

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

Если совсем уж по-простому, то символ & говорит — запусти всё одновременно и параллельно. Типа такого, с таким ты уже всяко встречался:

hostname & date & uname &

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

Это основной вариант, советую его и использовать, теперь давай рассмотрим альтернативные.

Есть еще такая утилита parallel, устанавливается как и все остальное apt/yum/brew install parallel

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

parallel -j 4 wget -q {} < urls.txt

Ключ -j означает сколько джобов будет запараллелено, что-то типа потоков/threads.

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

Ну и на закуску, есть такая штука «$!», она позволяет узнать PID последнего запущенного процесса. Давай на примере, запускай:

sleep 60 &
[1] 39032
echo $!
39032

В первой команде запустили фоном ожидание 60 секунд, вывелся порядковый номер джобы и PID. Ну а чтобы получить последний PID, выполняем третью команду с «$!». На экран вывелся PID в чистом виде, а дальше можешь его сохранить в переменную и уже проверять в скрипте, завершился он или нет.

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

tags: #bash #linux #utils
—
💩 @bashdays