mailer.cpp

Go to the documentation of this file.

#include <constants.h>
#include <email_sender.h>
#include <ini.h>
#include <logger.h>
#include <products.h>
 
#include <atomic>
#include <csignal>
#include <cstdlib>
#include <iostream>
#include <limits.h>
#include <pqxx/pqxx>
#include <setjmp.h>
#include <string>
#include <unistd.h>
#include <unordered_set>
 
#define SUCCESS (0)
#define FAILURE (-1)
 
/// Глобальный флаг последнего полученного сигнала.
volatile std::sig_atomic_t gSignalStatus;
 
/// jmp_buf для graceful shutdown (SIGINT/SIGTERM).
jmp_buf return_to_main;
/// jmp_buf для перезапуска цикла после SIGSEGV.
jmp_buf return_to_bottom;
 
/// Обработчик сигналов завершения (SIGINT/SIGTERM/SIGABRT/SIGFPE/SIGILL).
static void sigIntHandler(int signal);
 
/// Обработчик segmentation fault — перезапускает цикл.
static void sigsegvhandler(int signal);
 
/// Возвращает директорию, в которой находится исполняемый файл.
static std::string getApplicationDirectory();
 
/// Главный класс демона.
///
/// Управляет основным циклом: читает INI-конфиг, подключается к PostgreSQL,
/// проверяет таблицы заказов и отправляет email через SMTP.
class Daemon {
public:
  /// Конструктор.
  ///
  /// Инициализирует логгер, читает INI-файл (или генерирует шаблон),
  /// регистрирует старт в таблице products_log.
  Daemon() : running(true) {
    std::string appPath = getApplicationDirectory();
    Logger::Log();
    Logger::addOutput(
        (std::wstring(appPath.begin(), appPath.end()) + L"/mailer.log")
            .c_str());
    Logger::addOutput(std::wcout);
    Logger::setLevel(Logger::L_TRACE);
    Logger::setLevelFromEnv();
 
    LOGI(this->name.c_str() << ", version: " << this->version.c_str());
 
    LOGI("Logger initialized");
    LOGI((std::string("Executable path: ") + appPath).c_str());
 
    LOGT("Daemon constructor");
 
    LOGT("Initializing INI file handler");
    std::string iniFileName = appPath + "/mailer.ini";
    LOGI("INI path: " << iniFileName.c_str());
    iniFile = new mINI::INIFile(iniFileName);
 
    if (!iniFile->read(ini)) {
      mINI::INIStructure generatedIni;
      generatedIni["Mailer"].set({{{"sleepPeriod", "30"}}});
      generatedIni["MailSender"].set(
          {{"server", "mail.gentoos.ru"},
           {"port", "465"},
           {"protocol", "smtps"},
           {"sender", "e.anisimov@gentoos.ru"},
           {"password", "secret"},
           {"senderName", "Eugene Anisimov"},
           {"ordersMail", "orders@techno-liga74.ru"}});
      generatedIni["Postgres"].set({{"user", "K"},
                                    {"password", "secret"},
                                    {"host", "localhost"},
                                    {"port", "5432"},
                                    {"dbname", "K"},
                                    {"target_session_attrs", "read-write"}});
      if (iniFile->generate(generatedIni, false)) {
        LOGI("Failed to read INI file " << iniFileName.c_str()
                                        << ", example generated");
      } else
        LOGE("Failed to read INI file " << iniFileName.c_str());
    }
 
    try {
      LOGI("Registering program start");
      productsLog = new Products::ProductsLog(this->name, this->version);
      productsLog->postMessage("Service started");
    } catch (const std::exception &e) {
      LOGE("Failed to register program start" << std::endl << e.what());
    }
  };
 
  /// Деструктор. Освобождает INI-файл, логгирует остановку, отключается от PG.
  ~Daemon() {
    LOGT("Daemon destructor");
 
    LOGT("Disposing INI");
    delete iniFile;
 
    try {
      LOGI("Registering program stop");
      productsLog->postMessage("Service stopped");
      delete productsLog;
    } catch (const std::exception &e) {
      LOGE("Failed to register program start" << std::endl << e.what());
    }
 
    LOGT("Disconnecting Postgres");
    DisconnectPg();
    LOGT("Deinitializing EmailSender");
  }
 
  /// Останавливает основной цикл демона.
  void Stop() { running = false; }
 
  /// Основной цикл демона.
  ///
  /// На каждой итерации:
  ///   - перечитывает INI-файл (конфиг обновляется на лету);
  ///   - подключается к PostgreSQL;
  ///   - проверяет tab_siteOrders и tab_mobileOrders на новые заказы;
  ///   - отправляет email по каждому заказу;
  ///   - переходит в сон на sleepPeriod секунд.
  void Run() {
    int status = SUCCESS;
 
    do {
      // Read INI file every time
      if (!iniFile->read(ini)) {
        LOGE("Failed to read INI file");
        daemonSleep();
        continue;
      }
 
      try {
        ConnectPg();
      } catch (const std::exception &e) {
        LOGE(e.what());
        daemonSleep();
        continue;
      };
 
      status = sendOrders("tab_siteOrders");
      if (status != SUCCESS)
        LOGE("Error executing checkForSiteOrders");
      status = sendOrders("tab_mobileOrders");
      if (status != SUCCESS)
        LOGE("Error executing checkForSiteOrders");
 
      if (setjmp(return_to_bottom)) {
        LOGD("Bottom from sigsegv ");
        LOGD("Trying to reincarnate");
      }
 
      daemonSleep();
    } while (running);
  }
 
private:
#ifdef NAME
  std::string name = NAME; ///< Имя сервиса (по умолчанию "Mailer").
#else
  std::string name = "Mailer";
#endif
#ifdef VERSION
  std::string version = VERSION; ///< Версия (из CMake compile_definition).
#else
  std::string version = "Dev";
#endif
 
  mINI::INIFile *iniFile; ///< INI-файл конфигурации.
  mINI::INIStructure ini; ///< Структура INI-данных в памяти.
 
  std::string connectionStr = ""; ///< Строка подключения к PostgreSQL.
  pqxx::connection *connection = NULL; ///< Соединение с PostgreSQL.
  pqxx::work *trx = NULL;              ///< Текущая транзакция.
 
  Products::ProductsLog *productsLog = NULL; ///< Логирование старта/стопа в БД.
 
  volatile std::atomic<bool> running = false; ///< Флаг работы демона.
  int sleepPeriod = 60; ///< Пауза между итерациями (сек).
 
  /// Проверяет таблицу заказов и отправляет email по каждому неотправленному.
  ///
  /// SELECT unsent записей из tableName, группирует по ключу, формирует
  /// HTML-письмо с таблицей товаров, отправляет через EmailSender.
  /// При успехе отмечает sent=true.
  /// @param[in] tableName Имя таблицы ("tab_siteOrders" или
  /// "tab_mobileOrders").
  /// @return SUCCESS при успехе, FAILURE при ошибке SQL.
  int sendOrders(std::string tableName) {
    int status = SUCCESS;
 
    LOGI("Checking table " << tableName.c_str() << " for new orders");
 
    StartTransaction();
    pqxx::result res;
    try {
      res = trx->exec("select key, \"N_Cat\", \"Name\", price, count, sent, "
                      "phone, email from " +
                      tableName + " where sent=false");
    } catch (const std::exception &e) {
      LOGE("Failed to select from " << tableName.c_str());
      LOGE(e.what());
      return FAILURE;
    }
    AbortTransaction();
 
    std::unordered_set<std::string> keys;
    for (auto const &row : res) {
      // If we already handled this key, continue
      if (keys.contains(std::string(row["key"].c_str())))
        continue;
 
      LOGD("Sending mail to " << row["email"].c_str()
                              << " with ID: " << row["key"].c_str());
      StartTransaction();
      LOGD("Sending email with ID: " << row["key"].c_str() << " for "
                                     << row["email"].c_str());
 
      EmailSender email_sender(
          ini["EmailSender"]["server"],
          std::atoi(ini["EmailSender"]["port"].c_str()),
          ini["EmailSender"]["protocol"], ini["EmailSender"]["sender"],
          ini["EmailSender"]["password"], ini["EmailSender"]["senderName"]);
      email_sender.addRecvEmailAddr(ini["EmailSender"]["ordersMail"], "Orders");
      email_sender.addCcEmailAddr(row["email"].c_str(), row["phone"].c_str());
 
      // Generate e-mail body
      std::string subject =
          std::string("Заявка ") + row["key"].c_str() +
          (tableName == "tab_siteOrders" ? " с сайта"
                                         : " из мобильного приложения");
 
      std::string body =
          std::string("e-mail: <b>") + row["email"].c_str() +
          "</b><br>\nphone: <b>" + row["phone"].c_str() +
          "</b><br><br>\n"
          "<table border=\"1\">\n"
          "<tr><td>Кат. "
          "номер</td><td>Кол-во</td><td>Цена</td><td>Наименование</td></tr>\n";
      for (auto const &row_inner : res) {
        if (row_inner["key"] == row["key"])
          body += std::string("<tr>\n<td>") + row_inner["\"N_Cat\""].c_str() +
                  "</td>\n<td>" + row_inner["count"].c_str() + "</td>\n<td>" +
                  row_inner["price"].c_str() + "</td>\n<td>" +
                  row_inner["\"Name\""].c_str() + "</td>\n</tr>\n";
      }
      body += "</table>";
      // Set new subject and body
      email_sender.setEmailContent(subject, body);
 
      status = email_sender.send();
 
      if (status == SUCCESS) {
        LOGD("Updating email status for ID: " << row["key"].c_str());
        trx->exec_params("update " + tableName + " set sent=true where key=$1",
                         row["key"].c_str());
        CommitTransaction();
      } else {
        LOGD("Failed to send mail for ID: " << row["key"].c_str());
        AbortTransaction();
      }
 
      keys.insert(row["key"].c_str());
    }
 
    return status;
  };
 
  /// Подключается к PostgreSQL.
  ///
  /// Формирует строку подключения из секции [Postgres] INI-файла.
  /// Если подключение уже установлено и параметры не изменились — пропускает.
  /// @throw std::runtime_error при ошибке подключения.
  void ConnectPg() {
    std::string connStr =
        "user=" + ini["Postgres"]["user"] + " " +
        "password=" + ini["Postgres"]["password"] + " " +
        "host=" + ini["Postgres"]["host"] + " " +
        "port=" + ini["Postgres"]["port"] + " " +
        "dbname=" + ini["Postgres"]["dbname"] + " " +
        "target_session_attrs=" + ini["Postgres"]["target_session_attrs"];
    if (connection && (connStr == connectionStr)) {
      LOGT("Not reconnecting to PG, connection already established, "
           "connectionStr isn't changed");
      return;
    }
 
    connectionStr = connStr;
    try {
      // Connect to the database
      LOGI("Connecting to Postgresql");
      connection = new pqxx::connection(connectionStr);
    } catch (const std::exception &e) {
      throw std::runtime_error(e.what());
    }
  };
 
  /// Отключается от PostgreSQL.
  void DisconnectPg() {
    LOGI("Disconnecting Postgresql");
 
    if (connection && connection->is_open())
      connection->close();
    delete connection;
  }
 
  /// Создаёт новую транзакцию PostgreSQL.
  void StartTransaction() {
    LOGT("Starting transaction");
    trx = new pqxx::work(*connection);
  };
 
  /// Откатывает текущую транзакцию.
  void AbortTransaction() {
    LOGT("Aborting transaction");
    trx->abort();
    delete trx;
    trx = NULL;
  }
 
  /// Фиксирует текущую транзакцию.
  void CommitTransaction() {
    LOGT("Committing transaction");
    trx->commit();
    delete trx;
    trx = NULL;
  }
 
  /// Пауза между итерациями цикла.
  ///
  /// sleepPeriod читается из секции [Mailer] INI-файла на каждом вызове,
  /// поэтому изменение конфига применяется без перезапуска.
  void daemonSleep() {
    sleepPeriod = std::atoi(ini["Mailer"]["sleepPeriod"].c_str());
    if (sleepPeriod == 0)
      sleepPeriod = 30;
    LOGI("Sleeping for " << sleepPeriod << " seconds");
    sleep(sleepPeriod);
  }
};
 
/// Глобальный указатель на демон (доступен из signal handler'ов).
static Daemon *d;
 
/// Точка входа.
///
/// Устанавливает обработчики сигналов, создаёт Daemon, запускает цикл Run().
/// При SIGINT/SIGTERM/SIGABRT/SIGFPE/SIGILL происходит longjmp в эту же
/// функцию для graceful shutdown (Stop() + delete).
/// @return 0 при штатном завершении.
int main(void) {
  std::signal(SIGSEGV, &sigsegvhandler);
  std::signal(SIGINT, &sigIntHandler);
  std::signal(SIGABRT, &sigIntHandler);
  std::signal(SIGFPE, &sigIntHandler);
  std::signal(SIGILL, &sigIntHandler);
  std::signal(SIGTERM, &sigIntHandler);
 
  try {
    d = new Daemon();
  } catch (const std::exception &e) {
    LOGE(e.what());
  }
 
  if (setjmp(return_to_main)) {
    d->Stop();
    delete d;
  } else {
    try {
      d->Run();
    } catch (const std::exception &e) {
      LOGE(e.what());
    }
  }
 
  return 0;
}
 
/// Обработчик сигналов завершения.
///
/// Выполняет longjmp в main() для штатной остановки демона.
/// @param[in] signal Номер сигнала (SIGINT/SIGTERM/SIGABRT/SIGFPE/SIGILL).
static void sigIntHandler(int signal) {
  LOGD("Turning off daemon");
  LOGD("  Signal was " + signal);
  longjmp(return_to_main, 1);
}
 
/// Обработчик segmentation fault.
///
/// Выполняет longjmp в точку return_to_bottom внутри цикла Run(),
/// позволяя демону продолжить работу без полного перезапуска.
/// @param[in] signal Номер сигнала (SIGSEGV).
static void sigsegvhandler(int signal) {
  LOGD("Try again ");
  LOGD("  Signal was " + signal);
  longjmp(return_to_bottom, 1);
}
 
/// Возвращает директорию исполняемого файла.
///
/// Читает символическую ссылку /proc/self/exe и извлекает путь к
/// родительской директории. Конфиг и лог-файл ищутся рядом с бинарником.
/// @return Путь к директории с бинарником (без слеша на конце).
static std::string getApplicationDirectory() {
#ifdef _WIN32
  return GetModuleFilename(nullptr);
#else
  char result[PATH_MAX];
  ssize_t count = readlink("/proc/self/exe", result, PATH_MAX);
  std::string appPath = std::string(result, (count > 0) ? count : 0);
  std::size_t found = appPath.find_last_of("/\\");
  return appPath.substr(0, found);
#endif
}