products_log.cpp

Go to the documentation of this file.

/// \file products_log.cpp
/// \brief Реализация клиента ProductsLog.
 
#include "products_log/products_log.h"
 
#include <cctype>
#include <cstdio>
#include <cstdlib>
#include <sstream>
 
#include <curl/curl.h>
 
namespace products_log {
 
namespace {
 
std::string GetEnv(const char *name) {
  if (const char *v = std::getenv(name))
    return v;
  return "";
}
 
// Предупреждение идёт в stderr, как у остальных логов ebpf-blocker.
void Warn(const std::string &msg) {
  std::fprintf(stderr, "ProductsLog: %s\n", msg.c_str());
}
 
// Убирает завершающий слэш, как в Python-версии (rstrip("/")).
std::string StripTrailingSlash(std::string s) {
  while (!s.empty() && s.back() == '/')
    s.pop_back();
  return s;
}
 
struct CurlWriteBuffer {
  std::string data;
};
 
size_t CurlWriteCallback(char *ptr, size_t size, size_t nmemb, void *userdata) {
  auto *buf = static_cast<CurlWriteBuffer *>(userdata);
  buf->data.append(ptr, size * nmemb);
  return size * nmemb;
}
 
HttpResponse CurlTransportImpl(const HttpRequest &req) {
  HttpResponse resp;
 
  CURL *curl = curl_easy_init();
  if (!curl) {
    resp.error = "curl_easy_init failed";
    return resp;
  }
 
  curl_slist *headers = nullptr;
  if (!req.body.empty())
    headers = curl_slist_append(headers, "Content-Type: application/json");
 
  CurlWriteBuffer buf;
 
  curl_easy_setopt(curl, CURLOPT_URL, req.url.c_str());
  curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, CurlWriteCallback);
  curl_easy_setopt(curl, CURLOPT_WRITEDATA, &buf);
  curl_easy_setopt(curl, CURLOPT_TIMEOUT,
                   static_cast<long>(req.timeout_seconds));
  curl_easy_setopt(curl, CURLOPT_CONNECTTIMEOUT,
                   static_cast<long>(req.timeout_seconds));
  curl_easy_setopt(curl, CURLOPT_NOSIGNAL, 1L);
  curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
  curl_easy_setopt(curl, CURLOPT_USERAGENT, "products_log/1.0");
 
  if (!req.username.empty() || !req.password.empty()) {
    const std::string userpwd = req.username + ":" + req.password;
    curl_easy_setopt(curl, CURLOPT_USERPWD, userpwd.c_str());
  }
 
  if (req.method == "POST") {
    curl_easy_setopt(curl, CURLOPT_POST, 1L);
    curl_easy_setopt(curl, CURLOPT_POSTFIELDS, req.body.c_str());
    curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE,
                     static_cast<long>(req.body.size()));
  }
 
  const CURLcode rc = curl_easy_perform(curl);
  if (rc != CURLE_OK) {
    resp.error = curl_easy_strerror(rc);
  } else {
    resp.ok = true;
    long http_code = 0;
    curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &http_code);
    resp.status = static_cast<int>(http_code);
  }
 
  resp.body = buf.data;
  curl_slist_free_all(headers);
  curl_easy_cleanup(curl);
  return resp;
}
 
} // namespace
 
ProductsLog::ProductsLog(std::string product_name, std::string product_version,
                         Transport transport)
    : ProductsLog(std::move(product_name), std::move(product_version),
                  GetEnv("PRODUCTS_HOST"), GetEnv("PRODUCTS_USER"),
                  GetEnv("PRODUCTS_PASS"), std::move(transport)) {}
 
ProductsLog::ProductsLog(std::string product_name, std::string product_version,
                         std::string base_url, std::string username,
                         std::string password, Transport transport)
    : product_name_(std::move(product_name)),
      product_version_(product_version.empty() ? "UNKNOWN"
                                               : std::move(product_version)),
      base_url_(StripTrailingSlash(std::move(base_url))),
      username_(std::move(username)), password_(std::move(password)),
      transport_(std::move(transport)) {
  enabled_ = !base_url_.empty() && !username_.empty() && !password_.empty();
  if (!enabled_) {
    Warn("PRODUCTS_HOST / PRODUCTS_USER / PRODUCTS_PASS are not all set — "
         "statistics reporting is disabled.");
  }
}
 
Transport ProductsLog::DefaultTransport() {
  static const Transport impl = [](const HttpRequest &req) {
    return CurlTransportImpl(req);
  };
  return impl;
}
 
std::string ProductsLog::UrlEncode(const std::string &s) {
  static const char *hex = "0123456789ABCDEF";
  std::string out;
  out.reserve(s.size());
  for (unsigned char c : s) {
    if (std::isalnum(c) || c == '-' || c == '_' || c == '.' || c == '~') {
      out.push_back(static_cast<char>(c));
    } else {
      out.push_back('%');
      out.push_back(hex[c >> 4]);
      out.push_back(hex[c & 0x0F]);
    }
  }
  return out;
}
 
std::string ProductsLog::JsonEscape(const std::string &s) {
  std::ostringstream out;
  for (unsigned char c : s) {
    switch (c) {
    case '"':
      out << "\\\"";
      break;
    case '\\':
      out << "\\\\";
      break;
    case '\n':
      out << "\\n";
      break;
    case '\r':
      out << "\\r";
      break;
    case '\t':
      out << "\\t";
      break;
    case '\b':
      out << "\\b";
      break;
    case '\f':
      out << "\\f";
      break;
    default:
      if (c < 0x20) {
        static const char *hex = "0123456789abcdef";
        out << "\\u00" << hex[c >> 4] << hex[c & 0x0F];
      } else {
        out << static_cast<char>(c);
      }
    }
  }
  return out.str();
}
 
std::optional<int64_t> ProductsLog::ParseProductId(const std::string &body) {
  // Ищем ключ "id" и число после него: {"id": 42, ...} либо {"id":42}.
  const std::string marker = "\"id\"";
  std::size_t pos = body.find(marker);
  if (pos == std::string::npos)
    return std::nullopt;
 
  pos = body.find(':', pos + marker.size());
  if (pos == std::string::npos)
    return std::nullopt;
  ++pos;
 
  while (pos < body.size() &&
         std::isspace(static_cast<unsigned char>(body[pos])))
    ++pos;
 
  int64_t value = 0;
  bool negative = false;
  bool any = false;
  if (pos < body.size() && body[pos] == '-') {
    negative = true;
    ++pos;
  }
  while (pos < body.size() &&
         std::isdigit(static_cast<unsigned char>(body[pos]))) {
    value = value * 10 + (body[pos] - '0');
    any = true;
    ++pos;
  }
  if (!any)
    return std::nullopt;
  return negative ? -value : value;
}
 
bool ProductsLog::ResolveProductId() {
  if (product_id_.has_value())
    return true;
 
  if (auto id = FindProductId()) {
    product_id_ = id;
    return true;
  }
  if (auto id = RegisterProduct()) {
    product_id_ = id;
    return true;
  }
  return false;
}
 
bool ProductsLog::SendStat(int64_t product_id, const std::string &comment) {
  const std::string url = base_url_ + "/stats";
  std::ostringstream body;
  body << "{\"product\":{\"id\": " << product_id << "}," << "\"version\":\""
       << JsonEscape(product_version_) << "\", " << "\"comment\": \""
       << JsonEscape(comment) << "\"}";
 
  HttpRequest req{};
  req.method = "POST";
  req.url = url;
  req.body = body.str();
  req.username = username_;
  req.password = password_;
 
  HttpResponse resp;
  try {
    resp = transport_(req);
  } catch (...) {
    Warn("post_message failed: transport threw an exception");
    return false;
  }
 
  if (!resp.ok) {
    Warn("post_message failed: " +
         (resp.error.empty() ? "transport error" : resp.error));
    return false;
  }
  if (resp.status < 200 || resp.status >= 300) {
    std::ostringstream msg;
    msg << "post_message failed (HTTP " << resp.status << ")";
    Warn(msg.str());
    return false;
  }
  return true;
}
 
bool ProductsLog::PostMessage(const std::string &comment) {
  if (!enabled_ || !ResolveProductId())
    return false;
  return SendStat(*product_id_, comment);
}
 
bool ProductsLog::PostStart() { return PostMessage("Program started"); }
 
bool ProductsLog::PostShutdown() { return PostMessage("Program shutdown"); }
 
std::optional<int64_t> ProductsLog::FindProductId() {
  const std::string url =
      base_url_ + "/products/byName/" + UrlEncode(product_name_);
  HttpRequest req{};
  req.method = "GET";
  req.url = url;
  req.username = username_;
  req.password = password_;
 
  HttpResponse resp;
  try {
    resp = transport_(req);
  } catch (...) {
    Warn("failed to look up product: transport threw an exception");
    return std::nullopt;
  }
 
  if (!resp.ok) {
    Warn("failed to look up product: " +
         (resp.error.empty() ? "transport error" : resp.error));
    return std::nullopt;
  }
  if (resp.status != 200)
    return std::nullopt;
  return ParseProductId(resp.body);
}
 
std::optional<int64_t> ProductsLog::RegisterProduct() {
  const std::string url = base_url_ + "/products";
  HttpRequest req{};
  req.method = "POST";
  req.url = url;
  req.body = "{\"name\":\"" + JsonEscape(product_name_) + "\"}";
  req.username = username_;
  req.password = password_;
 
  HttpResponse resp;
  try {
    resp = transport_(req);
  } catch (...) {
    Warn("failed to register product: transport threw an exception");
    return std::nullopt;
  }
 
  if (!resp.ok) {
    Warn("failed to register product: " +
         (resp.error.empty() ? "transport error" : resp.error));
    return std::nullopt;
  }
  if (resp.status != 200 && resp.status != 201) {
    std::ostringstream msg;
    msg << "failed to register product (HTTP " << resp.status << ")";
    Warn(msg.str());
    return std::nullopt;
  }
  return ParseProductId(resp.body);
}
 
} // namespace products_log