- The Beginner’s Guide to Scripting on Linux
- Why would you make a script?
- Getting started – Shebangs
- Best Practices
- Making a script
- File Extensions
- Code resources
- Conclusion
- script command in Linux with Examples
- Bash-скрипты, часть 10: практические примеры
- Отправка сообщений в терминал пользователя
- ▍Команды who и mesg
- ▍Команда write
- ▍Создание скрипта для отправки сообщений
- ▍Проверка возможности записи в терминал пользователя
- ▍Проверка правильности вызова скрипта
- ▍Получение сведений о терминале пользователя
- ▍Отправка длинных сообщений
- Скрипт для мониторинга дискового пространства
- Итоги
The Beginner’s Guide to Scripting on Linux
Have you ever wanted to learn “scripting” in Linux? Making them is easier than you might think. Sometimes scripts (often referred to as shell or bash scripts) are real programs with complicated code inside. Other times they’re just a long list of tasks that users put together to make getting things done under Linux faster and easier.
In this article we’ve decided to make a quick guide explaining how to make a basic shell script under Linux. This tutorial won’t turn you into a Bash or scripting expert. Instead, it will show you how easy it is to get started (and the best practices) scripting in Linux.
Why would you make a script?
Making scripts in Linux is a very useful skill to have. Even if you don’t fully understand Bash, you can use your limited knowledge of the terminal to automate and “mass-accomplish” some tasks, or simply to open multiple applications simultaneously.
For example: maybe you just built Arch Linux from scratch. The operating system is installed, along with all of the basic packages, and it can boot to the terminal when the operating system starts up. Arch Linux takes time to set up, so the process isn’t completed.
It is at this point where the user could write a Bash script and accomplish everything at once. None of this is programming, or advanced for that matter. However, given the fact that the user understands enough about the way Arch Linux works, they’d be able to automate almost the entire post-setup process (desktop environment, drivers, user setup, etc.).
The only limit to your bash script is your own Linux and Bash knowledge! Making them is easier than you might think.
Getting started – Shebangs
When writing code, things need to be specified and resources loaded. When scripting with the shell, some things need to be specified as well. In bash scripting this is known as a “shebang.” The shebangs used in scripts tells the script what interpreter it should execute under. This could be Bash or any other scripts available in your system. Do note that different languages have their own shebangs.
For example: When writing a Python script, the shebang would be #!/usr/bin/python , etc.
Bash has many different shebangs that can be used, but most users have probably only seen the #!/bin/bash one. As a general rule, use #!/bin/bash when writing a simple script and don’t plan on taking it off of Linux. All modern Linux distributions are on the same version of bash, and the bash shell is usually located in the same place.
Another shebang that proves itself useful is the #!/usr/bin/env bash shebang. This one is designed for portability and should be used if the script is designed to run on other Unix-like operating systems (BSDs, macOS, etc.).
Best Practices
Writing scripts in Bash can be a complicated process if the writer makes it that way. More often than not, scripts are just a collection of different operations. Moving a file, downloading something, installing programs, and that sort of thing.
- Keep in mind that Bash is a language that is designed to manipulate files and processes on the system. If Bash meets your needs, that is good. However, do understand that for advanced programming, Bash really isn’t the right choice, and it’d be best to move onto something like Python.
- Make your scripts “SH” compatible and in the “.sh” format if the plan is to use scripts on more than just a Linux platform. Though other UNIX-like operating systems may have “bash-like” shells, some don’t have bash at all, and it’s good to be prepared for this.
- Learn the Bash shell and how it works. It’ll help you write your scripts better.
- Always use a shebang and more importantly: use the right one. It can mean the difference between a good script and a terrible one that doesn’t work right.
- Always comment out every operation. In six months you might come back to your script and wonder what everything means, so it is crucial that your script is documented well and easy to understand (for you and anyone else who might see it).
- Make your code readable. Even if your script isn’t anything complex, it should still make sense, and making them is easier than you might think.
- Test your script for errors before giving it out to others. Don’t make others bug test for you. Ideally, scripts should work before you send them out for people to use.
Making a script
To start scripting, all you need is a text editor. Any simple text editor will do – it doesn’t have to be a complicated or comprehensive one. For this example we’ll make a simple Ubuntu update script using Gedit.
This first part of the script is the shebang, like mentioned before. This allows the script to tell the interpreter what it should use to understand the code.
Next, let’s write a comment. This will allow anyone who uses the script to understand what the code is meant to do. Comments can be added to a script by placing a “#” symbol. Anything after it won’t be picked up by the script.
Now it is time to add the code to the script. In this case we’re working on making a bash script that will run Ubuntu’s two update commands in succession. Start off with the update software sources command.
The second part of the script is the apt upgrade command. This command allows the previously checked updates to be installed. Add a -y to the end so that the script won’t need any user interaction. This will allow the command to update by itself.
Save the script with a “.sh” extension. For example, “myscript.sh.”
To run the script, open a terminal and type:
This will mark the newly created script as executable. Doing this to scripts isn’t always required, as for the most part Bash will run it anyways. Regardless, this a good practice when scripting.
To execute the newly created script, run the following command:
File Extensions
There isn’t a difference in file extensions for scripts. Naming a file with the “.sh” file extension does little to affect the way the “program” runs. A Bash script will still run with no file extension – blank text files and everything in between as long as the right commands and arguments are present.
Even though the Bash shell ignores file extensions, that doesn’t mean the script writer should. Some desktop environments that allow for setting shell scripts to run at startup depend on the script to have the correct “.sh” file extension. This also helps for organization purposes, too.
When it comes down to it, most shell scripts are saved as “.sh” files for portability. The “sh” doesn’t have anything to do with Bash itself, and the script can run with any compatible shell.
Alternatively, scripts can be saved as .bash, .ksh (Unix korn shell), etc. These file extensions are inferior and really limit the usefulness of a script. This is due to the fact that they are designed only for the shells that use those extensions.
Code resources
For those looking for useful Bash scripts, check out the Bash User Repository on Reddit. It is a collection of neat and useful scripts that are free to use and modify!
Additionally, those looking to learn the advanced nature of Bash and programming with the shell should check out Freecode. The website has an entire lesson guide that teaches everything there is to know about advanced Bash scripting.
Conclusion
Though scripting with Bash on Linux isn’t a unique feature (Macs have bash too), it tends to help Linux users out more overall. Considering so much of Linux can be accomplished under the terminal, learning how to manipulate the shell is very useful.
What Bash scripts do you use under Linux to make your life easier? Tell us below!
Derrik Diener is a freelance technology blogger.
Источник
script command in Linux with Examples
script command in Linux is used to make typescript or record all the terminal activities. After executing the script command it starts recording everything printed on the screen including the inputs and outputs until exit. By default, all the terminal information is saved in the file typescript , if no argument is given. script is mostly used when we want to capture the output of a command or a set of command while installing a program or the logs generated on the terminal while compiling an opensource codes, etc. script command uses two files i.e. one for the terminal output and other for the timing information.
Syntax:
Example 1: To start a typescript without any argument. If no filename is given as argument, script will automatically create a file namely typescript in the home directory to save the recorded information.
Input:
In order to stop the typescript, we just need to execute exit command and script will stop the capturing process. Since there’s no filename given as argument, the script will automatically create a file namely typescript in the home directory to save the recorded information.
Example 2: To start the typrscript, run any random command and save it in a text file, let’s say geeksforgeeks.txt.
The output produced above is the content of the file geeksforgeeks.txt, created by script command.
Options:
- -a, –append: This option is used when we want to append the output, retaining the prior content of the file. The multiple contents get separated by adding a line that states the date and time of the script started.
Example:
-c, –command: This option is used when we want to run a particular command rather than interactive shell and get terminal information in the file given as argument or typescript by default. The script will automatically exit after successful execution.
Example: To get the typescript of cal command.
Example: To capture terminal activity in a file let’s say gfg2 that is stored in /home/sc.
-q, –quiet: This option does not display the notification stating that the script has started and quietly execute and exit the script command.
-t, –timing[=]: This option allows user to capture the terminal activity step by step and appears like a video when the recorded file is executed with the help of scriptreplay command.
Example: To capture terminal activity in a manual file, geeksforgeeks1.
This option contains two data fields. The first field indicates how much time elapsed since the previous output. The second field indicates how many characters were output this time. Now let’s check the output created using another command i.e. scriptreplay as follow:
-V, –version: Output version information and exit.
-h, –help: Display this help and exit
Источник
Bash-скрипты, часть 10: практические примеры
В предыдущих материалах мы обсуждали различные аспекты разработки bash-скриптов, говорили о полезных инструментах, но до сих пор рассматривали лишь небольшие фрагменты кода. Пришло время более масштабных проектов. А именно, здесь вы найдёте два примера. Первый — скрипт для отправки сообщений, второй пример — скрипт, выводящий сведения об использовании дискового пространства.
Главная ценность этих примеров для тех, кто изучает bash, заключается в методике разработки. Когда перед программистом встаёт задача по автоматизации чего бы то ни было, его путь редко бывает прямым и быстрым. Задачу надо разбить на части, найти средства решения каждой из подзадач, а потом собрать из частей готовое решение.
Отправка сообщений в терминал пользователя
В наши дни редко кто прибегает к одной из возможностей Linux, которая позволяет общаться, отправляя сообщения в терминалы пользователей, вошедших в систему. Сама по себе команда отправки сообщений, write , довольно проста. Для того, чтобы ей воспользоваться, достаточно знать имя пользователя и имя его терминала. Однако, для успешной отправки сообщения, помимо актуальных данных о пользователе и терминале, надо знать, вошёл ли пользователь в систему, не запретил ли он запись в свой терминал. В результате, перед отправкой сообщения нужно выполнить несколько проверок.
Как видите, задача: «отправить сообщение», при ближайшем рассмотрении, оказалась задачей: «проверить возможность отправки сообщения, и, если нет препятствий, отправить его». Займёмся решением задачи, то есть — разработкой bash-скрипта.
▍Команды who и mesg
Ядром скрипта являются несколько команд, которые мы ещё не обсуждали. Всё остальное должно быть вам знакомо по предыдущим материалам.
Первое, что нам тут понадобится — команда who . Она позволяет узнать сведения о пользователях, работающих в системе. В простейшем виде её вызов выглядит так:
Результаты вызова команды who
В каждой строчке, которую выводит команда who , нас интересуют первых два показателя — имя пользователя и сведения о его терминале.
По умолчанию запись в терминал разрешена, но пользователь может, с помощью команды mesg , запретить отправку ему сообщений. Таким образом, прежде чем пытаться что-то кому-то отправить, неплохо будет проверить, разрешена ли отправка сообщений. Если нужно узнать собственный статус, достаточно ввести команду mesg без параметров:
В данном случае команда вывела «is y», это значит, что пользователь, под которым мы работаем в системе, может принимать сообщения, отправленные в его терминал. В противном случае mesg выведет «is n».
Для проверки того, разрешена ли отправка сообщений какому-то другому пользователю, можно использовать уже знакомую вам команду who с ключом -T :
При этом проверка возможна только для пользователей, которые вошли в систему. Если такая команда, после имени пользователя, выведет чёрточку (-), это означает, что пользователь запретил запись в свой терминал, то есть, сообщения ему отправлять нельзя. О том, что пользователю можно отправлять сообщения, говорит знак «плюс» (+).
Если у вас приём сообщений отключён, а вы хотите позволить другим пользователям отправлять вам сообщения, можно воспользоваться такой командой:
Включение приёма сообщений от других пользователей
После включения приёма сообщений mesg возвращает «is y».
Конечно, для обмена сообщениями нужны два пользователя, поэтому мы, после обычного входа в систему, подключились к компьютеру по ssh. Теперь можно поэкспериментировать.
▍Команда write
Основной инструмент для обмена сообщениями между пользователями, вошедшими в систему — команда write . Если приём сообщений у пользователя разрешён, с помощью этой команды ему можно отправлять сообщения, используя его имя и сведения о терминале.
Обратите внимание на то, что с помощью write можно отправлять сообщения пользователям, вошедшим в виртуальную консоль. Пользователи, которые работают в графическом окружении (KDE, Gnome, Cinnamon, и так далее), не могут получать подобные сообщения.
Итак, мы, работая под пользователем likegeeks , инициируем сеанс связи с пользователем testuser , который работает в терминале pts/1 , следующим образом:
Проверка возможности отправки сообщений и отправка сообщения
После выполнения вышеуказанной команды перед нами окажется пустая строка, в которую нужно ввести первую строку сообщения. Нажав клавишу ENTER , мы можем ввести следующую строку сообщения. После того, как ввод текста завершён, окончить сеанс связи можно, воспользовавшись комбинацией клавиш CTRL + D , которая позволяет ввести символ конца файла.
Вот что увидит в своём терминале пользователь, которому мы отправили сообщение.
Новое сообщение, пришедшее в терминал
Получатель может понять от кого пришло сообщение, увидеть время, когда оно было отправлено. Обратите внимание на признак конца файла, EOF , расположенный в нижней части окна терминала. Он указывает на окончание текста сообщения.
Полагаем, теперь у нас есть всё необходимое для того, чтобы автоматизировать отправку сообщений с помощью сценария командной строки.
▍Создание скрипта для отправки сообщений
Прежде чем заниматься отправкой сообщений, нужно определить, вошёл ли интересующий нас пользователь в систему. Сделать это можно с помощью такой команды:
Здесь результаты работы команды who передаются команде grep . Ключ -i этой команды позволяет игнорировать регистр символов. Ключ -m 1 включён в вызов команды на тот случай, если пользователь вошёл в систему несколько раз. Эта команда либо не выведет ничего, либо выведет имя пользователя (его мы укажем при вызове скрипта, оно попадёт в позиционную переменную $1 ), соответствующее первому найденному сеансу. Вывод grep мы передаём awk . Эта команда, опять же, либо не выведет ничего, либо выведет элемент, записанный в собственную переменную $1 , то есть — имя пользователя. В итоге то, что получилось, попадает в переменную logged_on .
Теперь надо проверить переменную l ogged_on , посмотреть, есть ли в ней что-нибудь:
Если вы не вполне уверенно чувствуете себя, работая с конструкцией if , взгляните на этот материал.
Скрипт, содержащий вышеописанный код, сохраним в файле senderscript и вызовем, передав ему, в качестве параметра командной строки, имя пользователя testuser .
Проверка статуса пользователя
Тут мы проверяем, является ли logged_on переменной с нулевой длиной. Если это так, нам сообщат о том, что в данный момент пользователь в систему не вошёл и скрипт завершит работу с помощью команды exit . В противном случае выполнение скрипта продолжится.
▍Проверка возможности записи в терминал пользователя
Теперь надо проверить, принимает ли пользователь сообщения. Для этого понадобится такая конструкция, похожая на ту, которую мы использовали выше:
Проверка возможности отправки сообщений пользователю
Сначала мы вызываем команду who с ключом -T . В строке сведений о пользователе, который может принимать сообщения, окажется знак «плюс» (+), если же пользователь принимать сообщения не может — там будет чёрточка (-). То, что получилось после вызова who , передаётся grep , а потом — awk , формируя переменную allowed .
Далее, используя условный оператор, мы проверяем то, что оказалось в переменной allowed . Если знака «плюс» в ней нет, сообщим о том, что отправка сообщений пользователю запрещена и завершим работу. В противном случае выполнение сценария продолжится.
▍Проверка правильности вызова скрипта
Первым параметром скрипта является имя пользователя, которому мы хотим отправить сообщение. Вторым — текст сообщения, в данном случае — состоящий из одного слова. Для того, чтобы проверить, передано ли скрипту сообщение для отправки, воспользуемся таким кодом:
Проверка параметров командной строки, указанных при вызове скрипта
Тут, если при вызове скрипта ему не было передано сообщение для отправки, мы сообщаем об этом и завершаем работу. В противном случае — идём дальше.
▍Получение сведений о терминале пользователя
Прежде чем отправить пользователю сообщение, нужно получить сведения о терминале, в котором он работает и сохранить имя терминала в переменной. Делается это так:
Теперь, после того, как все необходимые данные собраны, осталось лишь отправить сообщение:
Вызов готового скрипта выглядит так:
Успешная отправка сообщения с помощью bash-скрипта
Как видно, всё работает как надо. Однако, с помощью такого сценария можно отправлять лишь сообщения, состоящие из одного слова. Хорошо бы получить возможность отправлять более длинные сообщения.
▍Отправка длинных сообщений
Попробуем вызвать сценарий senderscript , передав ему сообщение, состоящее из нескольких слов:
Попытка отправки длинного сообщения
Как видно, отправлено было лишь первое слово. Всё дело в том, что каждое слово сообщения воспринимается внутри скрипта как отдельная позиционная переменная. Для того, чтобы получить возможность отправки длинных сообщений, обработаем параметры командной строки, переданные сценарию, воспользовавшись командой shift и циклом while .
После этого, в команде отправки сообщения, воспользуемся, вместо применяемой ранее позиционной переменной $2 , переменной whole_message :
Вот полный текст сценария:
Успешная отправка длинного сообщения:
Длинное сообщение успешно дошло до адресата. Теперь рассмотрим следующий пример.
Скрипт для мониторинга дискового пространства
Сейчас мы собираемся создать сценарий командной строки, который предназначен для поиска в заданных директориях первой десятки папок, на которые приходится больше всего дискового пространства. В этом нам поможет команда du , которая выводит сведения о том, сколько места на диске занимают файлы и папки. По умолчанию она выводит сведения лишь о директориях, с ключом -a в отчёт попадают и отдельные файлы. Её ключ -s позволяет вывести сведения о размерах директорий. Эта команда позволяет, например, узнать объём дискового пространства, который занимают данные некоего пользователя. Вот как выглядит вызов этой команды:
Для наших целей лучше подойдёт ключ -S (заглавная S), так как он позволяет получить сведения как по корневой папке, так и по вложенным в неё директориям:
Вызов команды du с ключами -s и -S
Нам нужно найти директории, на которые приходится больше всего дискового пространства, поэтому список, который выдаёт du , надо отсортировать, воспользовавшись командой sort :
Отсортированный список объектов
Ключ -n указывает команде на то, что нужна числовая сортировка, ключ -r — на обратный порядок сортировки (самое большое число окажется в начале списка). Полученные данные вполне подходят для наших целей.
Для того, чтобы ограничить полученный список первыми десятью записями, воспользуемся потоковым редактором sed , который позволит удалить из полученного списка все строки, начиная с одиннадцатой. Следующий шаг — добавить к каждой полученной строке её номер. Тут также поможет sed , а именно — его команда N :
Приведём полученные данные в порядок, воспользовавшись awk . Передадим awk то, что получилось после обработки данных с помощью sed , применив, как и в других случаях, конвейер, и выведем полученные данные с помощью команды printf :
В начале строки выводится её номер, потом идёт двоеточие и знак табуляции, далее — объём дискового пространства, следом — ещё один знак табуляции и имя папки.
Соберём вместе всё то, о чём мы говорили:
Вывод сведений о дисковом пространстве
Для того, чтобы повысить эффективность работы скрипта, код которого вы совсем скоро увидите, реализуем возможность получения данных сразу по нескольким директориям. Для этого создадим переменную MY_DIRECTORIES и внесём в неё список интересующих нас директорий:
Переберём список с помощью цикла for и вызовем вышеописанную последовательность команд для каждого элемента списка. Вот что получилось в результате:
Получение сведений о нескольких директориях
Как видите, скрипт выводит, в виде удобного списка, сведения о директориях, список которых хранится в MY_DIRECTORIES .
Команду du в этом скрипте можно вызвать с другими ключами, полученный список объектов вполне можно отфильтровать, в целом — тут открывается широкий простор для самостоятельных экспериментов. В результате, вместо работы со списком папок, можно, например, найти самые большие файлы с расширением .log, или реализовать более сложный алгоритм поиска самых больших (или самых маленьких) файлов и папок.
Итоги
Сегодня мы подробно разобрали пару примеров разработки скриптов. Тут хотелось бы напомнить, что наша главная цель — не в том, чтобы написать скрипт для отправки сообщений с помощью команды write , или сценарий, который помогает в поиске файлов и папок, занимающих много места на диске, а в описании самого процесса разработки. Освоив эти примеры, поэкспериментировав с ними, возможно — дополнив их или полностью переработав, вы научитесь чему-то новому, улучшите свои навыки разработки bash-скриптов.
На сегодня это всё. В следующий раз поговорим об автоматизации работы с интерактивными утилитами с помощью expect.
Уважаемые читатели! Есть ли у вас на примете несложные (а может быть и сложные, но понятные) bash-скрипты, разбор которых будет полезен новичкам?
Источник
