О демонах

Прежде чем писать настоящих демонов попробуем начать с чего-то попроще.

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

Возможно самый близкий вам пример демона будет СУБД. То есть это некий сервис, у которого есть набор файлов, которыми он управляет, а если его хорошо попросить он с вами еще и какой-то информацией поделится

Попробуем написать программу которая будет мониторить папку и сообщать об изменениях которые в ней происходит.

Для отслеживания изменений в linux используется механизм inotify, про него даже можно прочитать в мануале

man inotify

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

Создаем болванку проекта

Создадим проект

mkdir cpp05
cd $_

создадим файлик main.cpp и запишем в него

#include <iostream>
#include <sys/inotify.h> // для работы с inotify
#include <unistd.h> // для чтения изменений

using namespace std;

int main(int argc, char* argv[]) {
        cout << "проверка" << endl;
        return 0;
}

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

Создаем Makefile

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

и напишем в него

build: 
	g++ main.cpp -o main
	./main

очень важно чтобы отступы были сделаны табами.

А теперь смотрите, достаточно написать

make

и наша программа автоматически соберется и запуститься.

если вы не хотите, чтобы писались команды, которые использовались для сборки или запуска, добавьте перед ними @

build: 
	@g++ main.cpp -o main
	@./main

Вообще, Makefile – это специальные файлы с помощью которых упрощают процесс сборки для С/C++ проектов, в том числе и ядро линукс использует Makefile, но они как правило очень большие. И есть даже специальные утилиты для генерации Makefile`ов

Мониторим папку с inotify

Схема работы с inotify в принципе достаточно простая

#include <iostream>
#include <sys/inotify.h>
#include <unistd.h>

using namespace std;

int main(int argc, char* argv[]) {
	// создаем файловый дескриптор для отслеживания
	int inotify_fd = inotify_init();

	// подключаем к inotify_fd мониторинг,
	// "/home/m" -- эта папка которую мониторим
	// IN_MODIFY | IN_CREATE | IN_DELETE -- события которые мониторим
	int watch_fd = inotify_add_watch(inotify_fd, "/home/m", IN_MODIFY | IN_CREATE | IN_DELETE);


	// А ТУТ СЕЙЧАС ХИТРОСТИ НАЧНУТЬСЯ

	return 0;
}

так как мы пишем демон, а демон работает бесконечно долго, то мы заводим бесконечный цикл и в этом цикле просто пытаемся читать с файлового дескриптора inotify_fd

// это мы выше написали
int inotify_fd = inotify_init();
int watch_fd = inotify_add_watch(inotify_fd, "/home/m", IN_MODIFY | IN_CREATE | IN_DELETE);


// а тут новое пошло 
// сначала бесконечный цикл
while(true) {
	char buffer[10000]; // буфер под события изменений
	
	// подключаемся к inotify_fd на чтение 
	// эта строчка блокирует программу, 
	// пока не произойдет какое-нибудь изменение
	int length = read(inotify_fd, buffer, 10000);

	// так как событие может прийти несколько то надо их все обойти
	int i = 0;
	while (i < length) {
		// вытаскиваем инфу по событию
		struct inotify_event *event = (struct inotify_event *)&buffer[i];

		// проверим тип события
		if (event->mask & IN_MODIFY) {
			// и выведем сообщение о событии
			// в event->name лежит имя файла
			cout << "изменился" << event->name << endl;
		}
		else if (event->mask & IN_CREATE) {
			cout << "создали файл" << event->name << endl;
		}

		// сдвигаемся на следующее событие
		i += sizeof(struct inotify_event) + event->len;
	}
	
}

inotify_rm_watch(inotify_fd, watch_fd);
close(inotify_fd);
return 0;

можно потестить

Теперь попробуйте сделать задание. Так как в задании надо читать и писать в файл, вот вам болванки кода, под эти операции.

Чтобы прочитать содержимое файла, используйте следующий код

std::ifstream ifs("/home/m/file.txt"); // читаем файл по пути
std::string content; // переменная под содержимое файл
if (ifs.is_open()) {
	// считываем содержимое файла в переменную
	content.assign((std::istreambuf_iterator<char>(ifs)), (std::istreambuf_iterator<char>())); 
	ifs.close();
}

чтобы записать что-нибудь в файл использует такой код

ofstream ofs("/home/m/file.txt");
if (ofs.is_open()) {
	ofs << str << endl;
	ofs.close();
}

Отслеживание конкретного файла

С помощью inotify можно мониторить не только папки, но и просто файлы. Для этого создавая watch_fd, просто укажите полный путь к файлу

int watch_fd = inotify_add_watch(inotify_fd, "/home/m/file.txt", IN_MODIFY);

в этом случае, при событии, у вас уже не будет имени файла event->name, но вы можете проверить, о каком файле пришло событие изменения сравнив event->wd с watch_fd

Если они совпали значит событие пришло о файле который мониторится с помощью watch_fd

int length = read(inotify_fd, buffer, EVENT_BUF_LEN);
int i = 0;
while (i < length)
{
    struct inotify_event *event = (struct inotify_event *)&buffer[i];
    if (event->mask & IN_MODIFY && event->wd == watch_fd) {
        cout << "файл изменился" << endl;
    }
}

Отключение события отслеживания

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

inotify_rm_watch(inotify_fd, watch_fd);

если же захотите включать отслеживание обратно, то просто еще раз вызовите

watch_fd = inotify_add_watch(inotify_fd, "/home/m/file.txt", IN_MODIFY);

Вызов bash команды из C++ и перехват вывода

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

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

std::string exec(string cmd) {
    std::array<char, 128> buffer; // буфер для перехвата вывода команды
    std::string result; // переменная в которой будет хранится итоговый полный вывод команды
    std::unique_ptr<FILE, decltype(&pclose)> pipe(popen(cmd.c_str(), "r"), pclose); // создаем процесс
    if (!pipe) {
        throw std::runtime_error("popen() failed!");
    }
    while (fgets(buffer.data(), buffer.size(), pipe.get()) != nullptr) { // и пока команда генерит текст
        result += buffer.data(); // подклеиваем его к нашей переменной result
    }
    return result;
}

Как ее использовать?

Например, хочу я запустить ls, тогда мне надо будет написать так

#include <iostream>
#include <sys/inotify.h>
#include <unistd.h>
#include <array> // добавил для работы с буффером
#include <memory> // добавил для работы с процессами

using namespace std;

// это скопипастил
std::string exec(string cmd) {
    std::array<char, 128> buffer; // буфер для перехвата вывода команды
    std::string result; // переменная в которой будет хранится итоговый полный вывод команды
    std::unique_ptr<FILE, decltype(&pclose)> pipe(popen(cmd.c_str(), "r"), pclose); // создаем процесс
    if (!pipe) {
        throw std::runtime_error("popen() failed!");
    }
    while (fgets(buffer.data(), buffer.size(), pipe.get()) != nullptr) { // и пока команда генерит текст
        result += buffer.data(); // подклеиваем его к нашей переменной result
    }
    return result;
}

int main(int argc, char* argv[]) {
	string result = exec("ls -la ."); // вызываем нашу функцию с командой которую хотим запустить
	cout << "Вы запустили команду и она выдала:" << endl;
	cout << result << endl;
	return 0;
}

теперь если запустить эту программу увидим

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

А переменную заполнила функцию exec. Вот такие вот дела.

Теперь попробуйте собрать из всей этой кучи кода задание

Супервизор Systemd

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

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

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

Для управления супервизором есть две основные команды.

• systemctl – для непосредственного управления сервисами (перезапуск, остановка, проверка статусов)
• journalctl – для просмотре логов

Например, можно запустить команду systemctl list-units --type=service и увидеть список всех сервисов доступных в системе

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

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

sudo systemctl cat ИМЯ_СЕРВИСА

например можно глянуть сервис который ответственен за общение VirtualBox и нашего линукса

sudo systemctl cat vboxadd.service

В выводе видим две наиболее интересных строчки. Первая это путь к файлу, в котором содержится описание сервиса /lib/systemd/system/vboxadd.service. Скоро мы сделаем свой такой.

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

Можно глянуть кстати, что лежит в папке /lib/systemd/system и увидеть, что там действительно есть такой файлик и еще куча других

ls /lib/systemd/system

каждый отвечает за какой-то свой сервис

Мы можем отредактировать каждый файлик либо прямо через, типа

sudo nano /lib/systemd/system/vboxadd.service

либо используя systemctl, вот так

sudo systemctl edit --full vboxadd.service

Регистрация сервиса

И так, чтобы наш сервис подключить к супервизору создадим файлик my_daemon.service:

и теперь опишем в него сервис

[Unit]
Description=Заклинатель книг  # название сервиса

[Service]
User=m  # под каким юзером запускать
# рабочая директория, в ней будет искаться config.txt
WorkingDirectory=/home/m/cpp05
# путь к скомпилированному файлу
ExecStart=/home/m/cpp05/main

[Install]
WantedBy=multi-user.target # хотим, чтобы запускалось при запуске системы

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

Теперь нам надо подключить этот файлик к супервизору.

Сначала надо положить его в папку /etc/systemd/system, чтобы проще было редактировать мы просто создадим ссылку на наш файл вот так:

sudo ln -s $PWD/my_daemon.service /etc/systemd/system

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

Переменная $PWD как раз хранит полный путь текущей папки.

теперь надо перегрузить кеш сервисов

sudo systemctl daemon-reload

у меня старый демон, который папку мониторит, вот с таким кодом

#include <iostream>
#include <sys/inotify.h>
#include <unistd.h>

using namespace std;

int main(int argc, char *argv[])
{
    int inotify_fd = inotify_init();
    int watch_fd = inotify_add_watch(inotify_fd, "/home/m", IN_MODIFY | IN_CREATE | IN_DELETE);

    while (true) {
        char buffer[10000];
        int length = read(inotify_fd, buffer, 10000);

        int i = 0;
        while (i < length) {
            struct inotify_event *event = (struct inotify_event *)&buffer[i];

            if (event->mask & IN_MODIFY) {
                cout << "изменился" << event->name << endl;
            }
            else if (event->mask & IN_CREATE) {
                cout << "создали файл" << event->name << endl;
            }

            i += sizeof(struct inotify_event) + event->len;
        }
    }

    inotify_rm_watch(inotify_fd, watch_fd);
    close(inotify_fd);
    return 0;
}

Момент истины, запускаем наш сервис:

sudo systemctl start my_daemon.service

теперь попробуем узнать статус нашего сервиса

sudo systemctl status my_daemon.service

если увидим такое

значит все работает =)

Давайте теперь протестируем как он работает

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

Journalctl

Утилита journalctl, позволяет смотреть логи по всему что происходит в системе, в том числе и по нашему демону.

Для просмотра журнала по своему демону надо ввести вот такую команду

sudo journalctl -u my_daemon.service

чтобы выйти из лога нажмите q

если хочется смотреть лог в режиме реального времени, то можно добавит флаг -f (--follow)

sudo journalctl -u my_daemon.service -f

работает практически мгновенно

Кстати, чтобы остановить процесс воспользуетесь командой

sudo systemctl stop my_daemon.service

в логе зафиксируется момент и причина остановки.

И еще один важный момент чтобы ваш демон действительно запустился при перезапуске системы надо активировать сервис командой enable

sudo systemctl enable my_daemon.service

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

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

Но что будет, если по какой-то причине в коде произойдет непредвиденная ситуация и произойдет исключение.

Давайте попробуем смоделировать такую ситуацию.

Генерим ошибку

Чтобы вызывать ошибку надо добавить в заголовки

#include <stdexcept>

и внутри программы добавить конструкцию

throw runtime_error("Падаю =ООО");

например сделаю так:

#include <iostream>
#include <sys/inotify.h>
#include <unistd.h>
#include <stdexcept> // ДОБАВИЛ

using namespace std;

int main(int argc, char *argv[])
{
    int inotify_fd = inotify_init();
    int watch_fd = inotify_add_watch(inotify_fd, "/home/m", IN_MODIFY | IN_CREATE | IN_DELETE);

     cout << "-=-=-=-=-=-" << endl 
     << "ЗАПУСКАЮСЬ" << endl
     << "-=-=-=-=-=-" << endl;
     
    while (true) {
        char buffer[10000];
        int length = read(inotify_fd, buffer, 10000);

        int i = 0;
        while (i < length) {
            struct inotify_event *event = (struct inotify_event *)&buffer[i];

            // ТУТ ПАДАЮ ЕСЛИ ПРОИЗОШЛО СОБЫТИЕ
            throw runtime_error("Падаю =ООО");
            
            i += sizeof(struct inotify_event) + event->len;
        }
    }

    inotify_rm_watch(inotify_fd, watch_fd);
    close(inotify_fd);
    return 0;
}

перезапустим нашего демона и глянем лог чтобы понять как оно работает

ну разве не прекрасно, падает с концами =)

Только зачем?)

Подключаем автоперезапуск

Одной из важнейших задач супервизора является оживление упавших процессов.

В общем, чтобы наш процесс после умирания сразу восстанавливался необходимо добавить в описание сервиса (файл my_daemon.service) строчку

[Unit]
Description=Заклинатель книг

[Service]
User=m
Restart=on-failure # вот эту
WorkingDirectory=/home/m/cpp05
ExecStart=/home/m/cpp05/main

[Install]
WantedBy=multi-user.target

полный список допустимых значений такой

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

man systemd.service

после того как подправите файлик надо обновить кэш systemd и перезапустить сервис

sudo systemctl daemon-reload
sudo systemctl restart my_daemon.service

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

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

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

К счастью существует более эффективный способ общения с юзером. С помощью так называемых сокетов.

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

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

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

Есть разные протоколы взаимодействия с сервером. Мы будем использовать протокол TCP/IP, потому что данный протокол предполагает создание диалога между пользователем (клиентом) и демоном (сервером), что идеально подходит под нашу ситуацию. Можно теперь забыть про наш старый код с FileSystemWatcher-ом и циклом с Thread.Sleep. Теперь у нас будет нормальный сервер который сам будет ждать соединения, в общем, пишем:

using System;
using System.Net.Sockets;
using System.Text;

namespace App
{
    class Program {
        public  static void Main(String[] args) {
            // проверяем не создали ли мы сокет файл уже
            // и если создали то удаляем старый файл
            if (File.Exists("daemon.socket")) {
                File.Delete("daemon.socket");
            }
            
            // собственно создаем канал для сокета
            UnixDomainSocketEndPoint endPoint = new("daemon.socket");
            // создаем объекта сокета
            var socket = new Socket(
                endPoint.AddressFamily,
                SocketType.Stream,
                ProtocolType.IP
            );
            
            // подключаем к каналу
            socket.Bind(endPoint);
            // и начинаем слушать соединения
            socket.Listen();

            while(true) {
                Console.WriteLine("Жду приказов");
                
                var handler = socket.Accept(); // эта строка блокирует код пока кто-нибудь не подключится к сокету
                
                // как только кто-то подключился мы можем начать обрабатывать команды от юзера
                while (true) {  
                    var bytes = new Byte[1024];   // буфер под введенные данные
                    int bytesRec = handler.Receive(bytes);   // эта штука по сути аналог Console.ReadLine()
                    var input = Encoding.UTF8.GetString(bytes); // только полученные байты превращаем в строку
                    var output = $"Вы написали {input}"; // формируем ответ
                    handler.Send(Encoding.UTF8.GetBytes(output)); // посылаем ответ, преобразуя его обратно в байты
                }  
            }
        }
    }
}

попробуем запустить

dotnet run

если глянуть, то увидим, что в папке появился файлик daemon.socket

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

Можно попробовать туда чего-нибудь echoнуть

правда оно не сработает так как это не настоящий файл.

В общем чтобы к нему подключится нам потребуется специальная программа для подключения к сокетам. Называется она socat. Ставим ее себе

sudo apt install socat

Теперь попробуем подключится к серверу. Пишем

socat UNIX-CLIENT:daemon.socket -

и попробуем чего-нибудь пописать

чтобы остановить общение надо нажать Ctrl+C

это разорвет соединения socat, и заодно убьет наш сервер так для него такая ситуация является нештатной, что конечно такое себе.

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

// ...
while(true) {
    // тут не трогаем
    Console.WriteLine("Жду приказов");

    var handler = socket.Accept(); 
    
    // а цикл правим
    while (true) {  
        try { // обернул в try
            // тут старый код который раньше был в while
            var bytes = new Byte[1024]; 
            int bytesRec = handler.Receive(bytes);
            var input = Encoding.UTF8.GetString(bytes);
            var output = $"Вы написали {input}";
            handler.Send(Encoding.UTF8.GetBytes(output));
        } catch (SocketException) { // ловлю ошибку
            // в случае ошибки пишу об этом
            Console.WriteLine("Произошёл разрыв соединения");  
            // закрываю соединения аккуратно
            handler.Shutdown(SocketShutdown.Both); 
            handler.Close();  
            break; // и выхожу из цикла перехвата ввода
        }
    }  
}
// ...

Пробуем запустить

Отлично!

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

Делается это так

using System;
using System.Net;  // не забыть добавть using
using System.Net.Sockets;
using System.Text;

namespace App
{
    class Program {
        public  static void Main(String[] args) {
            // узнаем системный IP
            IPHostEntry ipHostInfo = Dns.GetHostEntry(Dns.GetHostName());  
            IPAddress ipAddress = ipHostInfo.AddressList[0];  
            // создаем точку подключения
            IPEndPoint endPoint = new IPEndPoint(ipAddress, 8080);  
            Console.WriteLine($"Слушаю запросы на {ipAddress}:8080");
            
            // ну и дальше как обычно
            var socket = new Socket(
                endPoint.AddressFamily,
                SocketType.Stream,
                ProtocolType.IP
            );
            
            socket.Bind(endPoint);
            socket.Listen();
            
            //...
        }
    }
}

И теперь если захочется подключится к серверу просто пишем вот так:

socat TCP:127.0.1.1:8080 -

вот теперь другое дело, можно пилить задачу

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

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

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

Для этого воспользуемся возможностью писать асинхронные штуки в C#

Я пока не успел тут дописать методичку, так что пока можете потыкать сами =)

https://docs.microsoft.com/ru-ru/dotnet/framework/network-programming/asynchronous-server-socket-example