Merge common/ and selfdrive/common (#24556)

* Merge common/ and selfdrive/common * fix that * fix version * fix unit tests old-commit-hash: cb8885cffb313bea258c012c3026461a22bf8135
2026-08-21 08:14:00 +08:00 · 2022-05-18 14:11:57 -07:00
parent eea872ae98
commit f4675fc260
140 changed files with 288 additions and 287 deletions
@@ -0,0 +1,2 @@
+test_util
+test_swaglog
@@ -0,0 +1,92 @@
+#include <zmq.h>
+#include <iostream>
+#define CATCH_CONFIG_MAIN
+#include "catch2/catch.hpp"
+
+#include "json11.hpp"
+#include "common/swaglog.h"
+#include "common/util.h"
+#include "common/version.h"
+#include "selfdrive/hardware/hw.h"
+
+const char *SWAGLOG_ADDR = "ipc:///tmp/logmessage";
+std::string daemon_name = "testy";
+std::string dongle_id = "test_dongle_id";
+int LINE_NO = 0;
+
+void log_thread(int thread_id, int msg_cnt) {
+  for (int i = 0; i < msg_cnt; ++i) {
+    LOGD("%d", thread_id);
+    LINE_NO = __LINE__ - 1;
+    usleep(1);
+  }
+}
+
+void recv_log(int thread_cnt, int thread_msg_cnt) {
+  void *zctx = zmq_ctx_new();
+  void *sock = zmq_socket(zctx, ZMQ_PULL);
+  zmq_bind(sock, SWAGLOG_ADDR);
+  std::vector<int> thread_msgs(thread_cnt);
+  int total_count = 0;
+
+  for (auto start = std::chrono::steady_clock::now(), now = start;
+       now < start + std::chrono::seconds{1} && total_count < (thread_cnt * thread_msg_cnt);
+       now = std::chrono::steady_clock::now()) {
+    char buf[4096] = {};
+    if (zmq_recv(sock, buf, sizeof(buf), ZMQ_DONTWAIT) <= 0) {
+      if (errno == EAGAIN || errno == EINTR || errno == EFSM) continue;
+      break;
+    }
+
+    REQUIRE(buf[0] == CLOUDLOG_DEBUG);
+    std::string err;
+    auto msg = json11::Json::parse(buf + 1, err);
+    REQUIRE(!msg.is_null());
+
+    REQUIRE(msg["levelnum"].int_value() == CLOUDLOG_DEBUG);
+    REQUIRE_THAT(msg["filename"].string_value(), Catch::Contains("test_swaglog.cc"));
+    REQUIRE(msg["funcname"].string_value() == "log_thread");
+    REQUIRE(msg["lineno"].int_value() == LINE_NO);
+
+    auto ctx = msg["ctx"];
+
+    REQUIRE(ctx["daemon"].string_value() == daemon_name);
+    REQUIRE(ctx["dongle_id"].string_value() == dongle_id);
+    REQUIRE(ctx["dirty"].bool_value() == true);
+
+    REQUIRE(ctx["version"].string_value() == COMMA_VERSION);
+
+    std::string device = "pc";
+    if (Hardware::TICI()) {
+      device = "tici";
+    }
+    REQUIRE(ctx["device"].string_value() == device);
+
+    int thread_id = atoi(msg["msg"].string_value().c_str());
+    REQUIRE((thread_id >= 0 && thread_id < thread_cnt));
+    thread_msgs[thread_id]++;
+    total_count++;
+  }
+  for (int i = 0; i < thread_cnt; ++i) {
+    INFO("thread :" << i);
+    REQUIRE(thread_msgs[i] == thread_msg_cnt);
+  }
+  zmq_close(sock);
+  zmq_ctx_destroy(zctx);
+}
+
+TEST_CASE("swaglog") {
+  setenv("MANAGER_DAEMON", daemon_name.c_str(), 1);
+  setenv("DONGLE_ID", dongle_id.c_str(), 1);
+  setenv("dirty", "1", 1);
+  const int thread_cnt = 5;
+  const int thread_msg_cnt = 100;
+
+  std::vector<std::thread> log_threads;
+  for (int i = 0; i < thread_cnt; ++i) {
+    log_threads.push_back(std::thread(log_thread, i, thread_msg_cnt));
+  }
+  for (auto &t : log_threads) t.join();
+
+  recv_log(thread_cnt, thread_msg_cnt);
+}
@@ -0,0 +1,145 @@
+
+#include <dirent.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+
+#include <algorithm>
+#include <climits>
+#include <random>
+#include <string>
+
+#define CATCH_CONFIG_MAIN
+#include "catch2/catch.hpp"
+#include "common/util.h"
+
+std::string random_bytes(int size) {
+  std::random_device rd;
+  std::independent_bits_engine<std::default_random_engine, CHAR_BIT, unsigned char> rbe(rd());
+  std::string bytes(size + 1, '\0');
+  std::generate(bytes.begin(), bytes.end(), std::ref(rbe));
+  return bytes;
+}
+
+TEST_CASE("util::read_file") {
+  SECTION("read /proc/version") {
+    std::string ret = util::read_file("/proc/version");
+    REQUIRE(ret.find("Linux version") != std::string::npos);
+  }
+  SECTION("read from sysfs") {
+    std::string ret = util::read_file("/sys/power/wakeup_count");
+    REQUIRE(!ret.empty());
+  }
+  SECTION("read file") {
+    char filename[] = "/tmp/test_read_XXXXXX";
+    int fd = mkstemp(filename);
+
+    REQUIRE(util::read_file(filename).empty());
+
+    std::string content = random_bytes(64 * 1024);
+    write(fd, content.c_str(), content.size());
+    std::string ret = util::read_file(filename);
+    REQUIRE(ret == content);
+    close(fd);
+  }
+  SECTION("read directory") {
+    REQUIRE(util::read_file(".").empty());
+  }
+  SECTION("read non-existent file") {
+    std::string ret = util::read_file("does_not_exist");
+    REQUIRE(ret.empty());
+  }
+  SECTION("read non-permission") {
+    REQUIRE(util::read_file("/proc/kmsg").empty());
+  }
+}
+
+TEST_CASE("util::file_exists") {
+  char filename[] = "/tmp/test_file_exists_XXXXXX";
+  int fd = mkstemp(filename);
+  REQUIRE(fd != -1);
+  close(fd);
+
+  SECTION("existent file") {
+    REQUIRE(util::file_exists(filename));
+    REQUIRE(util::file_exists("/tmp"));
+  }
+  SECTION("nonexistent file") {
+    std::string fn = filename;
+    REQUIRE(!util::file_exists(fn + "/nonexistent"));
+  }
+  SECTION("file has no access permissions") {
+    std::string fn = "/proc/kmsg";
+    std::ifstream f(fn);
+    REQUIRE(f.good() == false);
+    REQUIRE(util::file_exists(fn));
+  }
+  ::remove(filename);
+}
+
+TEST_CASE("util::read_files_in_dir") {
+  char tmp_path[] = "/tmp/test_XXXXXX";
+  const std::string test_path = mkdtemp(tmp_path);
+  const std::string files[] = {".test1", "'test2'", "test3"};
+  for (auto fn : files) {
+    std::ofstream{test_path + "/" + fn} << fn;
+  }
+  mkdir((test_path + "/dir").c_str(), 0777);
+
+  std::map<std::string, std::string> result = util::read_files_in_dir(test_path);
+  REQUIRE(result.find("dir") == result.end());
+  REQUIRE(result.size() == std::size(files));
+  for (auto& [k, v] : result) {
+    REQUIRE(k == v);
+  }
+}
+
+
+TEST_CASE("util::safe_fwrite") {
+  char filename[] = "/tmp/XXXXXX";
+  int fd = mkstemp(filename);
+  close(fd);
+  std::string dat = random_bytes(1024 * 1024);
+
+  FILE *f = util::safe_fopen(filename, "wb");
+  REQUIRE(f != nullptr);
+  size_t size = util::safe_fwrite(dat.data(), 1, dat.size(), f);
+  REQUIRE(size == dat.size());
+  int ret = util::safe_fflush(f);
+  REQUIRE(ret == 0);
+  ret = fclose(f);
+  REQUIRE(ret == 0);
+  REQUIRE(dat == util::read_file(filename));
+}
+
+TEST_CASE("util::create_directories") {
+  system("rm /tmp/test_create_directories -rf");
+  std::string dir = "/tmp/test_create_directories/a/b/c/d/e/f";
+
+  auto check_dir_permissions = [](const std::string &dir, mode_t mode) -> bool {
+    struct stat st = {};
+    return stat(dir.c_str(), &st) == 0 && (st.st_mode & S_IFMT) == S_IFDIR && (st.st_mode & (S_IRWXU | S_IRWXG | S_IRWXO)) == mode;
+  };
+
+  SECTION("create_directories") {
+    REQUIRE(util::create_directories(dir, 0755));
+    REQUIRE(check_dir_permissions(dir, 0755));
+  }
+  SECTION("dir already exists") {
+    REQUIRE(util::create_directories(dir, 0755));
+    REQUIRE(util::create_directories(dir, 0755));
+  }
+  SECTION("a file exists with the same name") {
+    REQUIRE(util::create_directories(dir, 0755));
+    int f = open((dir + "/file").c_str(), O_RDWR | O_CREAT);
+    REQUIRE(f != -1);
+    close(f);
+    REQUIRE(util::create_directories(dir + "/file", 0755) == false);
+    REQUIRE(util::create_directories(dir + "/file/1/2/3", 0755) == false);
+  }
+  SECTION("end with slashs") {
+    REQUIRE(util::create_directories(dir + "/", 0755));
+  }
+  SECTION("empty") {
+    REQUIRE(util::create_directories("", 0755) == false);
+  }
+}