Update the context per minute

Author: kunlinyu

include/dbus2http/Dbus2Http.h

@@ -20,6 +20,9 @@ class Dbus2Http {
   std::thread service_thread_;
   std::unique_ptr<sdbus::IConnection> conn_;
 
+  std::thread update_thread_;
+  bool stop_ = false;
+
  public:
   Dbus2Http(const std::vector<std::string>& service_prefixes, bool system_bus);
 
@@ -31,6 +34,8 @@ class Dbus2Http {
 
  private:
   bool match_prefix(const std::string& service_name);
+
+  void update();
 };
 
 }  // namespace dbus2http

include/dbus2http/DbusEnumerator.h

@@ -4,7 +4,6 @@
 
 #pragma once
 
-#include <plog/Log.h>
 #include <sdbus-c++/IConnection.h>
 
 #include <string>
@@ -37,7 +36,6 @@ class DbusEnumerator {
     std::vector<ObjectPath> result;
     result.emplace_back(object);
     context_.add(service_name, object);
-    PLOGI << service_name << "  " << object.path;
     for (const auto& child : object.children_paths) {
       std::string child_path = path + (path == "/" ? "" : "/") + child;
       std::vector<ObjectPath> child_ops =

include/dbus2http/entity/DbusSerialization.h

@@ -90,9 +90,10 @@ class Dbus2Html {
 
  public:
   static void set_ws_port(const std::string& port) { ws_port = port; }
+
   static std::string to_html(
-      const std::map<std::string, std::map<std::string, ObjectPath>>&
-          object_paths);
+      const InterfaceContext & context);
+
   static std::string to_html(const ObjectPath& op,
                              const std::string& service_name = "");
 

include/dbus2http/entity/InterfaceContext.h

@@ -6,33 +6,70 @@
 
 #include <map>
 #include <string>
+#include <mutex>
 
 #include "interface.h"
 #include "object_path.h"
 
 namespace dbus2http {
 
-struct InterfaceContext {
+class InterfaceContext {
   std::map<std::string, std::map<std::string, ObjectPath>> object_paths;
   std::map<std::string, Interface> interfaces;
+  mutable std::recursive_mutex mutex;
 
+ public:
   void add(const Interface& interface) {
+    std::unique_lock lock(mutex);
     interfaces[interface.name] = interface;
   };
 
   void add(const std::string& service_name,
            const ObjectPath& object_path) {
+    std::unique_lock lock(mutex);
     object_paths[service_name][object_path.path] = object_path;
   }
 
+  Interface get_interfaces(const std::string& interface_name) const {
+    std::unique_lock lock(mutex);
+    return interfaces.at(interface_name);
+  }
+
+  ObjectPath get_object_path(const std::string& service_name, const std::string& path_string) const {
+    std::unique_lock lock(mutex);
+    return object_paths.at(service_name).at(path_string);
+  }
+
+  std::vector<std::string> get_service_names() const {
+    std::unique_lock lock(mutex);
+    std::vector<std::string> service_names;
+    for (const auto& [service_name, _] : object_paths)
+      service_names.push_back(service_name);
+    return service_names;
+  }
 
+  std::vector<std::string> get_object_path_string(const std::string& service_name) const {
+    std::unique_lock lock(mutex);
+    std::vector<std::string> object_path_strings;
+    if (not contains_service(service_name)) return object_path_strings;
+    for (const auto& [path, object_path] : object_paths.at(service_name))
+      object_path_strings.push_back(path);
+    return object_path_strings;
+  }
 
   bool contains_service(const std::string& service_name) const {
+    std::unique_lock lock(mutex);
     return object_paths.contains(service_name);
   }
 
+  bool contains_interface(const std::string& interface_name) const {
+    std::unique_lock lock(mutex);
+    return interfaces.contains(interface_name);
+  }
+
   const std::map<std::string, ObjectPath>& object_paths_of_service(
       const std::string& service_name) const {
+    std::unique_lock lock(mutex);
     if (object_paths.contains(service_name))
       return object_paths.at(service_name);
     throw std::invalid_argument("service not found: " + service_name);
@@ -41,6 +78,7 @@ struct InterfaceContext {
   template <typename T>
   [[nodiscard]] const T& get(const std::string& interface_name,
                              const std::string& member_name) const {
+    std::unique_lock lock(mutex);
     if (interfaces.contains(interface_name))
       return interfaces.at(interface_name).get<T>(member_name);
     throw std::invalid_argument("interface not found: " + interface_name);

src/Dbus2Http.cpp

@@ -6,45 +6,49 @@
 namespace dbus2http {
 
 Dbus2Http::Dbus2Http(const std::vector<std::string>& service_prefixes,
-                            bool system)
+                     bool system)
     : system_bus_(system) {
   service_prefixes_.insert(service_prefixes.begin(), service_prefixes.end());
   conn_ = DbusUtils::createConnection(system_bus_);
 }
 
 void Dbus2Http::start(int port, int ws_port) {
-  DbusEnumerator dbusEnumerator(context_);
-  auto service_names = DbusEnumerator::list_services(system_bus_);
-  for (const auto& service_name : service_names) {
-    if (not match_prefix(service_name)) continue;
-    PLOGI << "servcie name: " << service_name;
-    PLOGI << "object paths: ";
-    std::vector<ObjectPath> object_paths =
-        dbusEnumerator.parse_object_paths_recursively(*conn_.get(), service_name, "/");
-    object_paths.erase(std::remove_if(object_paths.begin(), object_paths.end(),
-                                      [](const ObjectPath& op) {
-                                        return op.interfaces.empty();
-                                      }),
-                       object_paths.end());
-  }
-
   dbus_caller_ = std::make_unique<DbusCaller>(context_, system_bus_);
   service_ = std::make_unique<WebService>(*dbus_caller_);
   service_thread_ = std::thread([&] { service_->run(port, ws_port); });
-  // nlohmann::json j;
-  // j["object_paths"] = context_.object_paths;
-  // j["interfaces"] = context_.interfaces;
-  // PLOGI << j.dump();
+  update_thread_ = std::thread([&] {
+    while (not stop_) {
+      update();
+      for (int i = 0; i < 60 and not stop_; ++i)
+        std::this_thread::sleep_for(std::chrono::seconds(1));
+    }
+  });
   PLOGI << "dbus2http started on port " << port << "...";
 }
 
 void Dbus2Http::stop() {
+  stop_ = true;
+  PLOGI << "stopping httplib service update thread...";
+  if (update_thread_.joinable()) update_thread_.join();
+  PLOGI << "httplib service update thread stopped.";
   PLOGI << "stopping httplib service...";
   service_->stop();
   if (service_thread_.joinable()) service_thread_.join();
   PLOGI << "httplib service stopped.";
 }
 
+void Dbus2Http::update() {
+  DbusEnumerator dbusEnumerator(context_);
+  auto service_names = DbusEnumerator::list_services(system_bus_);
+  for (const auto& service_name : service_names) {
+    if (not match_prefix(service_name)) continue;
+    if (context_.contains_service(service_name)) continue;
+    PLOGI << "Found new service: " << service_name;
+    dbusEnumerator.parse_object_paths_recursively(*conn_.get(), service_name,
+                                                  "/");
+  }
+}
+
 bool Dbus2Http::match_prefix(const std::string& service_name) {
   if (service_prefixes_.empty()) return true;
   for (const auto& prefix : service_prefixes_) {
@@ -53,4 +57,4 @@ bool Dbus2Http::match_prefix(const std::string& service_name) {
   return false;
 }
 
-}
+}  // namespace dbus2http

src/DbusSerialization.cpp

@@ -190,19 +190,20 @@ Flags DbusSerialization::parse_flags(const tinyxml2::XMLElement* parent_node) {
 }
 
 std::string Dbus2Html::ws_port;
-
 std::string Dbus2Html::to_html(
-    const std::map<std::string, std::map<std::string, ObjectPath>>&
-        object_paths) {
+    const InterfaceContext & context) {
   std::ostringstream oss;
-  for (const auto& [service_name, paths] : object_paths) {
+  for (const auto& service_name : context.get_service_names()) {
     oss << "<details>";
     oss << "<summary>" << service_name << "</summary>";
-    for (const auto& [path, op] : paths) oss << to_html(op, service_name);
+    for (const auto& path : context.get_object_path_string(service_name)) {
+      oss << to_html(context.get_object_path(service_name, path), service_name);
+    }
     oss << "</details>";
   }
   return oss.str();
 }
+
 std::string Dbus2Html::to_html(const ObjectPath& op,
                                const std::string& service_name) {
   std::ostringstream oss;

src/WebService.cpp

@@ -4,8 +4,8 @@
 #include <dbus2http/WebService.h>
 #include <dbus2http/entity/DbusSerialization.h>
 
-#include <utility>
 #include <ranges>
+#include <utility>
 
 // #embed "../dbus2http_openapi.yaml" as dbus2http_openapi_yaml
 
@@ -18,7 +18,6 @@ bool WebService::parse_dbus_request_path(const std::string& path,
                                          std::string& object_path,
                                          std::string& interface_name,
                                          std::string& method) {
-
   std::string rem = path;
   const auto first_slash = rem.find('/');
   if (first_slash == std::string::npos) {
@@ -100,22 +99,20 @@ WebService::WebService(DbusCaller& caller) : caller_(caller) {
 )";
 
   bool ret = server_.set_mount_point("/", "/opt/cosmos/var/www/dbus2http");
-  if (not ret)
-    PLOGW << "set mount point failed";
+  if (not ret) PLOGW << "set mount point failed";
 
   // List DBus services
   server_.Get("/dbus/service", [this](const auto& req, auto& res) {
     nlohmann::json j;
     j["services"] = nlohmann::json::array();
-    for (const auto& service_name :
-         caller_.context().object_paths | std::views::keys) {
+    for (const auto& service_name : caller_.context().get_service_names()) {
       j["services"].push_back(service_name);
     }
     res.set_content(j.dump(), "application/json");
   });
   server_.Get("/dbus/html", [&, header, footer](const auto& req, auto& res) {
     res.set_content(
-        header + Dbus2Html::to_html(caller_.context().object_paths) + footer,
+        header + Dbus2Html::to_html(caller_.context()) + footer,
         "text/html");
   });
   server_.Get(R"(/dbus/interface/html/(.*))", [&, header, footer](
@@ -124,9 +121,9 @@ WebService::WebService(DbusCaller& caller) : caller_(caller) {
     Dbus2Html::set_ws_port(std::to_string(ws_port_));
     if (suffix.find('/') == std::string::npos) {
       const std::string& interface_name = suffix;
-      if (caller_.context().interfaces.contains(interface_name)) {
+      if (caller_.context().contains_interface(interface_name)) {
         const Interface& interface =
-            caller_.context().interfaces.at(interface_name);
+            caller_.context().get_interfaces(interface_name);
         res.set_content(header + Dbus2Html::to_html(interface) + footer,
                         "text/html");
       } else {
@@ -139,8 +136,8 @@ WebService::WebService(DbusCaller& caller) : caller_(caller) {
     std::string suffix = req.matches[1];
     if (suffix.find('/') == std::string::npos) {
       const std::string& interface_name = suffix;
-      if (caller_.context().interfaces.contains(interface_name)) {
-        nlohmann::json j = caller_.context().interfaces.at(interface_name);
+      if (caller_.context().contains_interface(interface_name)) {
+        nlohmann::json j = caller_.context().get_interfaces(interface_name);
         res.set_content(j.dump(2), "application/json");
       } else {
         res.status = 404;
@@ -197,7 +194,8 @@ WebService::WebService(DbusCaller& caller) : caller_(caller) {
       res.set_content(R"({"message": ")" + what + "\"}", "application/json");
     }
   });
-  server_.Get(R"(/dbus/try/(.*))", [this, try_html](const auto& req, auto& res) {
+  server_.Get(R"(/dbus/try/(.*))", [this, try_html](const auto& req,
+                                                    auto& res) {
     std::string service_name, object_path, interface_name, method;
     if (!parse_dbus_request_path(req.matches[1], service_name, object_path,
                                  interface_name, method)) {
@@ -224,8 +222,10 @@ WebService::WebService(DbusCaller& caller) : caller_(caller) {
       filled_html = replaceAll(filled_html, "$method_name$", method);
       const auto& method_type =
           caller_.context().get<Method>(interface_name, method);
-      filled_html = replaceAll(filled_html, "$request_signature$", method_type.in_signature());
-      filled_html = replaceAll(filled_html, "$response_signature$", method_type.out_signature());
+      filled_html = replaceAll(filled_html, "$request_signature$",
+                               method_type.in_signature());
+      filled_html = replaceAll(filled_html, "$response_signature$",
+                               method_type.out_signature());
       res.set_content(filled_html, "text/html");
     } catch (const std::exception& e) {
       res.status = 500;

src/main.cpp

@@ -109,6 +109,8 @@ int main(int argc, char* argv[]) {
   // std::thread dbus_thread([&conn] { RunExample(conn); });
   // std::this_thread::sleep_for(std::chrono::milliseconds(10));
 
+  std::this_thread::sleep_for(std::chrono::seconds(5));
+
   // launch dbus2http proxy
   PLOGI << "Starting dbus2http...";
   dbus2http::Dbus2Http dbus2http(service_prefix, program.get<bool>("--system"));