From 4253f5862c41dc0cab498183d546996e3311fa8b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=B3n=20Bjarni=20Bjarnason?= <jbbjarnason@gmail.com>
Date: Sun, 8 Oct 2023 11:57:18 +0000
Subject: [PATCH 01/33] create helper method to generate name for dbus
 connection

---
 exes/operations/inc/details/app_operation_mode_impl.hpp | 2 +-
 libs/dbus_util/CMakeLists.txt                           | 2 ++
 libs/dbus_util/inc/public/tfc/dbus/string_maker.hpp     | 2 ++
 libs/dbus_util/src/string_maker.cpp                     | 8 ++++++++
 4 files changed, 13 insertions(+), 1 deletion(-)

diff --git a/exes/operations/inc/details/app_operation_mode_impl.hpp b/exes/operations/inc/details/app_operation_mode_impl.hpp
index 0dff71480c..b732f7d3fb 100644
--- a/exes/operations/inc/details/app_operation_mode_impl.hpp
+++ b/exes/operations/inc/details/app_operation_mode_impl.hpp
@@ -40,7 +40,7 @@ app_operation_mode<signal_t, slot_t>::app_operation_mode(boost::asio::io_context
     message.signal_send();
   });
 
-  dbus_->request_name(operation::dbus::name.data());
+  dbus_->request_name(tfc::dbus::make_dbus_process_name().c_str());
 
   dbus_interface_->initialize();
 
diff --git a/libs/dbus_util/CMakeLists.txt b/libs/dbus_util/CMakeLists.txt
index ae0fbbddce..7b1b4ec932 100644
--- a/libs/dbus_util/CMakeLists.txt
+++ b/libs/dbus_util/CMakeLists.txt
@@ -19,6 +19,8 @@ target_link_libraries(dbus_util
     magic_enum::magic_enum
     tfc::stx
     tfc::configure_options
+  PRIVATE
+    tfc::base
 )
 
 add_library_to_docs(tfc::dbus_util)
diff --git a/libs/dbus_util/inc/public/tfc/dbus/string_maker.hpp b/libs/dbus_util/inc/public/tfc/dbus/string_maker.hpp
index 129234ca6d..6d780ad823 100644
--- a/libs/dbus_util/inc/public/tfc/dbus/string_maker.hpp
+++ b/libs/dbus_util/inc/public/tfc/dbus/string_maker.hpp
@@ -55,4 +55,6 @@ auto make_dbus_name(std::string_view input_name) -> std::string;
 /// \throws exception::invalid_name if input contains `-` or `//`
 auto make_dbus_path(std::string_view input_name) -> std::string;
 
+auto make_dbus_process_name() -> std::string;
+
 }  // namespace tfc::dbus
diff --git a/libs/dbus_util/src/string_maker.cpp b/libs/dbus_util/src/string_maker.cpp
index 8276eab99c..97b709abf8 100644
--- a/libs/dbus_util/src/string_maker.cpp
+++ b/libs/dbus_util/src/string_maker.cpp
@@ -1,5 +1,8 @@
+#include <fmt/format.h>
+
 #include <tfc/dbus/exception.hpp>
 #include <tfc/dbus/string_maker.hpp>
+#include <tfc/progbase.hpp>
 
 namespace tfc::dbus {
 
@@ -33,4 +36,9 @@ auto make_dbus_path(std::string_view input_name) -> std::string {
   return return_value;
 }
 
+auto make_dbus_process_name() -> std::string {
+  auto postfix{ fmt::format("tfc.{}.{}", tfc::base::get_exe_name(), tfc::base::get_proc_name()) };
+  return make_dbus_name(postfix);
+}
+
 }  // namespace tfc::dbus

From ff891edcc0c3d331b3c04117b9b713476090fa54 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=B3n=20Bjarni=20Bjarnason?= <jbbjarnason@gmail.com>
Date: Sun, 8 Oct 2023 12:07:31 +0000
Subject: [PATCH 02/33] reusing same connection within operations exe

---
 exes/operations/inc/details/app_operation_mode_impl.hpp  | 7 +++----
 exes/operations/inc/details/state_machine_owner_impl.hpp | 8 +++++---
 exes/operations/inc/state_machine_owner.hpp              | 6 ++++--
 3 files changed, 12 insertions(+), 9 deletions(-)

diff --git a/exes/operations/inc/details/app_operation_mode_impl.hpp b/exes/operations/inc/details/app_operation_mode_impl.hpp
index b732f7d3fb..a9f7095f1b 100644
--- a/exes/operations/inc/details/app_operation_mode_impl.hpp
+++ b/exes/operations/inc/details/app_operation_mode_impl.hpp
@@ -16,10 +16,9 @@ template <template <typename, typename> typename signal_t, template <typename, t
 app_operation_mode<signal_t, slot_t>::app_operation_mode(boost::asio::io_context& ctx)
     : dbus_{ std::make_shared<sdbusplus::asio::connection>(ctx, tfc::dbus::sd_bus_open_system()) },
       dbus_object_server_{ std::make_unique<sdbusplus::asio::object_server>(dbus_) },
-      dbus_interface_{ dbus_object_server_->add_interface(
-          std::string{ operation::dbus::path.data(), operation::dbus::path.size() },
-          std::string{ operation::dbus::name.data(), operation::dbus::name.size() }) },
-      state_machine_{ std::make_unique<state_machine_owner_t>(ctx) }, logger_{ "app_operation_mode" } {
+      dbus_interface_{ dbus_object_server_->add_interface(std::string{ operation::dbus::path },
+                                                          std::string{ operation::dbus::name }) },
+      state_machine_{ std::make_unique<state_machine_owner_t>(ctx, dbus_) }, logger_{ "app_operation_mode" } {
   dbus_interface_->register_signal<operation::update_message>(
       std::string(operation::dbus::signal::update.data(), operation::dbus::signal::update.size()));
 
diff --git a/exes/operations/inc/details/state_machine_owner_impl.hpp b/exes/operations/inc/details/state_machine_owner_impl.hpp
index 5d785f1154..63ef282225 100644
--- a/exes/operations/inc/details/state_machine_owner_impl.hpp
+++ b/exes/operations/inc/details/state_machine_owner_impl.hpp
@@ -10,9 +10,11 @@ namespace tfc::operation {
 // clang-format off
 template <template <typename, typename> typename signal_t, template <typename, typename> typename slot_t, template <typename, typename...> typename sml_t>
 // clang-format on
-state_machine_owner<signal_t, slot_t, sml_t>::state_machine_owner(asio::io_context& ctx)
-    : ctx_{ ctx }, states_{ std::make_shared<state_machine_t>(detail::state_machine<state_machine_owner>{ *this },
-                                                              tfc::logger::sml_logger{}) } {}
+state_machine_owner<signal_t, slot_t, sml_t>::state_machine_owner(asio::io_context& ctx,
+                                                                  std::shared_ptr<sdbusplus::asio::connection> conn)
+    : ctx_{ ctx }, dbus_{ std::move(conn) },
+      states_{ std::make_shared<state_machine_t>(detail::state_machine<state_machine_owner>{ *this },
+                                                 tfc::logger::sml_logger{}) } {}
 
 // clang-format off
 template <template <typename, typename> typename signal_t, template <typename, typename> typename slot_t, template <typename, typename...> typename sml_t>
diff --git a/exes/operations/inc/state_machine_owner.hpp b/exes/operations/inc/state_machine_owner.hpp
index 94d0647ad5..aca4ad2449 100644
--- a/exes/operations/inc/state_machine_owner.hpp
+++ b/exes/operations/inc/state_machine_owner.hpp
@@ -13,6 +13,7 @@
 #include <tfc/stx/concepts.hpp>
 #include <tfc/utils/asio_fwd.hpp>
 #include <tfc/utils/pragmas.hpp>
+#include <tfc/dbus/sdbusplus_fwd.hpp>
 
 namespace tfc::operation {
 
@@ -46,7 +47,7 @@ template <template <typename description_t, typename manager_client_t = ipc_rule
           template <typename, typename...> typename sml_t = boost::sml::sm>
 class state_machine_owner {
 public:
-  explicit state_machine_owner(asio::io_context&);
+  explicit state_machine_owner(asio::io_context&, std::shared_ptr<sdbusplus::asio::connection>);
 
   auto set_mode(tfc::operation::mode_e new_mode) -> std::error_code;
 
@@ -94,12 +95,13 @@ class state_machine_owner {
 private:
   std::function<void(new_mode, old_mode)> on_new_state_{};
   asio::io_context& ctx_;
+  std::shared_ptr<sdbusplus::asio::connection> dbus_;
 
   using bool_signal_t = signal_t<ipc::details::type_bool>;
   using bool_slot_t = slot_t<ipc::details::type_bool>;
   using string_signal_t = signal_t<ipc::details::type_string>;
   using uint_signal_t = signal_t<ipc::details::type_uint>;
-  ipc_ruler::ipc_manager_client mclient_{ ctx_ };
+  ipc_ruler::ipc_manager_client mclient_{ dbus_ };
   bool_signal_t stopped_{ ctx_, mclient_, "stopped" };
   bool_signal_t starting_{ ctx_, mclient_, "starting" };
   bool_signal_t running_{ ctx_, mclient_, "running" };

From 5e5f5e1e3002c76174a842e93d3c20c6b3a9885d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=B3n=20Bjarni=20Bjarnason?= <jbbjarnason@gmail.com>
Date: Sun, 8 Oct 2023 12:42:04 +0000
Subject: [PATCH 03/33] small refactor of dbus interface owning for slot

---
 libs/ipc/inc/public/tfc/ipc.hpp               | 10 +++----
 .../inc/public/tfc/ipc/details/dbus_slot.hpp  | 28 ++++++++-----------
 2 files changed, 16 insertions(+), 22 deletions(-)

diff --git a/libs/ipc/inc/public/tfc/ipc.hpp b/libs/ipc/inc/public/tfc/ipc.hpp
index 4cb850dc1c..426e4c499c 100644
--- a/libs/ipc/inc/public/tfc/ipc.hpp
+++ b/libs/ipc/inc/public/tfc/ipc.hpp
@@ -67,7 +67,7 @@ class slot {
               callb(new_value);
               dbus_slot_.emit_value(new_value);
             }) },
-        dbus_slot_{ client.connection(), [this] -> std::optional<value_t> const& { return this->value(); } },
+        dbus_slot_{ client.connection(), full_name(), [this] -> std::optional<value_t> const& { return this->value(); } },
         client_{ client } {
     client_init(description);
   }
@@ -85,7 +85,7 @@ class slot {
               callb(new_value);
               dbus_slot_.emit_value(new_value);
             }) },
-        dbus_slot_{ connection, [this] -> std::optional<value_t> const& { return this->value(); } }, client_{ connection } {
+        dbus_slot_{ connection, full_name(), [this] -> std::optional<value_t> const& { return this->value(); } }, client_{ connection } {
     client_init(description);
   }
 
@@ -111,12 +111,12 @@ class slot {
 
 private:
   void client_init(std::string_view description) {
-    client_.register_connection_change_callback(slot_->name_w_type(), [this](std::string_view signal_name) {
+    client_.register_connection_change_callback(full_name(), [this](std::string_view signal_name) {
       slot_->connect(signal_name);  //
     });
-    client_.register_slot(slot_->name_w_type(), description, type_desc::value_e, details::register_cb(slot_->name_w_type()));
+    client_.register_slot(full_name(), description, type_desc::value_e, details::register_cb(full_name()));
 
-    dbus_slot_.initialize(full_name());
+    dbus_slot_.initialize();
   }
 
   std::shared_ptr<details::slot_callback<type_desc>> slot_;
diff --git a/libs/ipc/inc/public/tfc/ipc/details/dbus_slot.hpp b/libs/ipc/inc/public/tfc/ipc/details/dbus_slot.hpp
index 653d9cf7d9..4eb57c6ec9 100644
--- a/libs/ipc/inc/public/tfc/ipc/details/dbus_slot.hpp
+++ b/libs/ipc/inc/public/tfc/ipc/details/dbus_slot.hpp
@@ -17,7 +17,7 @@ namespace asio = boost::asio;
 
 namespace dbus::tags {
 static constexpr std::string_view value{ "Value" };
-static constexpr std::string_view slot{ "Slot" };
+static constexpr std::string_view slot{ "Slots" };
 static constexpr std::string_view path{ tfc::dbus::const_dbus_path<slot> };
 }  // namespace dbus::tags
 
@@ -26,19 +26,14 @@ class dbus_slot {
 public:
   using value_t = slot_value_t;
 
-  explicit dbus_slot(asio::io_context& ctx, auto&& value_getter)
-      : dbus_slot(std::make_shared<sdbusplus::asio::connection>(ctx), std::forward<decltype(value_getter)>(value_getter)) {}
-  explicit dbus_slot(std::shared_ptr<sdbusplus::asio::connection> conn, auto&& value_getter)
-      : conn_{ std::move(conn) }, value_getter_{ std::forward<decltype(value_getter)>(value_getter) } {}
-  asio::io_context& io_context() const noexcept { return conn_->get_io_context(); }
-  std::shared_ptr<sdbusplus::asio::connection> connection() const noexcept { return conn_; }
-  void initialize(std::string_view slot_name) {
-    if (!conn_) {
-      return;
-    }
-    interface_ = std::make_unique<sdbusplus::asio::dbus_interface>(
-        conn_, std::string{ dbus::tags::path },
-        tfc::dbus::make_dbus_name(fmt::format("{}.{}", slot_name, dbus::tags::value)));
+  explicit dbus_slot(std::shared_ptr<sdbusplus::asio::connection> conn, std::string_view slot_name, auto&& value_getter)
+      : interface_{ std::make_shared<sdbusplus::asio::dbus_interface>(conn,
+                                                                      std::string{ dbus::tags::path },
+                                                                      tfc::dbus::make_dbus_name(slot_name)) },
+        value_getter_{ std::forward<decltype(value_getter)>(value_getter) } {
+
+  }
+  void initialize() {
     interface_->register_property_r<value_t>(std::string{ dbus::tags::value }, sdbusplus::vtable::property_::emits_change,
                                              [this]([[maybe_unused]] value_t& old_value) {
                                                if (auto current_value = value_getter_(); current_value.has_value()) {
@@ -47,8 +42,8 @@ class dbus_slot {
                                                return value_t{};
                                              });
     interface_->initialize();
-    conn_->request_name(tfc::dbus::make_dbus_name(fmt::format("{}._slot_", slot_name)).c_str());
   }
+  auto interface() const noexcept -> std::shared_ptr<sdbusplus::asio::dbus_interface> { return interface_; }
 
   void emit_value(value_t const& value) {
     if (interface_) {
@@ -57,8 +52,7 @@ class dbus_slot {
   }
 
 private:
-  std::shared_ptr<sdbusplus::asio::connection> conn_;
-  std::unique_ptr<sdbusplus::asio::dbus_interface, std::function<void(sdbusplus::asio::dbus_interface*)>> interface_{};
+  std::shared_ptr<sdbusplus::asio::dbus_interface> interface_{};
   std::function<std::optional<value_t> const&()> value_getter_{};
 };
 

From 6f367741332093cecde66b6e25fb03ce313750fc Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=B3n=20Bjarni=20Bjarnason?= <jbbjarnason@gmail.com>
Date: Sun, 8 Oct 2023 12:55:47 +0000
Subject: [PATCH 04/33] broken build but wip

---
 .../public/tfc/confman/detail/config_dbus_client.hpp |  7 +++----
 libs/confman/src/detail/config_dbus_client.cpp       | 12 +++++++++---
 2 files changed, 12 insertions(+), 7 deletions(-)

diff --git a/libs/confman/inc/public/tfc/confman/detail/config_dbus_client.hpp b/libs/confman/inc/public/tfc/confman/detail/config_dbus_client.hpp
index 4b887cb340..c0e3d3a56b 100644
--- a/libs/confman/inc/public/tfc/confman/detail/config_dbus_client.hpp
+++ b/libs/confman/inc/public/tfc/confman/detail/config_dbus_client.hpp
@@ -35,6 +35,7 @@ static constexpr std::string_view property_name{ "config" };
 class config_dbus_client {
 public:
   using dbus_connection_t = std::shared_ptr<sdbusplus::asio::connection>;
+  using interface_t = std::shared_ptr<sdbusplus::asio::dbus_interface>;
 
   /// \brief Empty constructor
   /// \note Should only be used for testing !!!
@@ -45,22 +46,20 @@ class config_dbus_client {
   using change_call_t = std::function<std::error_code(std::string_view)>;
   config_dbus_client(asio::io_context& ctx, std::string_view key, value_call_t&&, schema_call_t&&, change_call_t&&);
   config_dbus_client(dbus_connection_t conn, std::string_view key, value_call_t&&, schema_call_t&&, change_call_t&&);
-
-  [[nodiscard]] auto io_context() const noexcept -> asio::io_context& { return ctx_; }
+  config_dbus_client(interface_t intf, value_call_t&&, schema_call_t&&, change_call_t&&);
 
   void set(config_property&&) const;
 
   void initialize();
 
 private:
-  asio::io_context& ctx_;
   std::filesystem::path interface_path_{};
   std::string interface_name_{};
   value_call_t value_call_{};
   schema_call_t schema_call_{};
   change_call_t change_call_{};
   dbus_connection_t dbus_connection_{};
-  std::unique_ptr<sdbusplus::asio::dbus_interface, std::function<void(sdbusplus::asio::dbus_interface*)>> dbus_interface_{};
+  std::shared_ptr<sdbusplus::asio::dbus_interface> dbus_interface_{};
 };
 
 }  // namespace tfc::confman::detail
diff --git a/libs/confman/src/detail/config_dbus_client.cpp b/libs/confman/src/detail/config_dbus_client.cpp
index de2d9934c1..4025c1ffc9 100644
--- a/libs/confman/src/detail/config_dbus_client.cpp
+++ b/libs/confman/src/detail/config_dbus_client.cpp
@@ -18,15 +18,19 @@ namespace tfc::confman::detail {
 // busctl --system introspect com.skaginn3x.config.operation_mode.def.state_machine /com/skaginn3x/etc/tfc/config
 // clang-format on
 
-config_dbus_client::config_dbus_client(boost::asio::io_context& ctx) : ctx_{ ctx } {}
+namespace dbus::tags {
+static constexpr std::string_view config{ "Config" };
+static constexpr std::string_view path{ tfc::dbus::const_dbus_path<config> };
+}  // namespace dbus::tags
+
+config_dbus_client::config_dbus_client(boost::asio::io_context& ctx) {}
 
 config_dbus_client::config_dbus_client(dbus_connection_t conn,
                                        std::string_view key,
                                        value_call_t&& value_call,
                                        schema_call_t&& schema_call,
                                        change_call_t&& change_call)
-    : ctx_{ conn->get_io_context() },
-      interface_path_{ tfc::dbus::make_dbus_path(fmt::format("{}config", base::get_config_directory().string().substr(1))) },
+    : interface_path_{ dbus::tags::path },
       interface_name_{ tfc::dbus::make_dbus_name(
           fmt::format("config.{}.{}.{}", base::get_exe_name(), base::get_proc_name(), key)) },
       value_call_{ std::move(value_call) }, schema_call_{ std::move(schema_call) }, change_call_{ std::move(change_call) },
@@ -46,6 +50,8 @@ config_dbus_client::config_dbus_client(asio::io_context& ctx,
   dbus_connection_->request_name(interface_name_.c_str());
 }
 
+config_dbus_client::config_dbus_client(interface_t intf, value_call_t&&, schema_call_t&&, change_call_t&&) : dbus_interface_{ intf } {}
+
 void config_dbus_client::set(config_property&& prop) const {
   if (dbus_interface_) {
     dbus_interface_->set_property(std::string{ dbus::property_name }, prop);

From ddb751d236c67a6d099ca768d59cc89432daad27 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=B3n=20Bjarni=20Bjarnason?= <jbbjarnason@gmail.com>
Date: Mon, 9 Oct 2023 08:19:15 +0000
Subject: [PATCH 05/33] exposing injectable dbus interface to config dbus
 client

---
 libs/confman/inc/public/tfc/confman.hpp       | 27 +++++++++++--------
 .../tfc/confman/detail/config_dbus_client.hpp | 12 ++++++++-
 .../confman/src/detail/config_dbus_client.cpp | 23 +++++++++-------
 3 files changed, 41 insertions(+), 21 deletions(-)

diff --git a/libs/confman/inc/public/tfc/confman.hpp b/libs/confman/inc/public/tfc/confman.hpp
index 0cd518ff8f..95b5c791f4 100644
--- a/libs/confman/inc/public/tfc/confman.hpp
+++ b/libs/confman/inc/public/tfc/confman.hpp
@@ -1,10 +1,15 @@
 #pragma once
 
+#include <filesystem>
 #include <functional>
+#include <string>
 #include <string_view>
+#include <system_error>
 #include <type_traits>
+#include <memory>
 
 #include <glaze/glaze.hpp>
+#include <fmt/format.h>
 
 #include <tfc/confman/detail/change.hpp>
 #include <tfc/confman/detail/config_dbus_client.hpp>
@@ -49,13 +54,9 @@ class config {
   config(asio::io_context& ctx, std::string_view key, storage_type&& def)
       : client_{ ctx, key, std::bind_front(&config::string, this), std::bind_front(&config::schema, this),
                  std::bind_front(&config::from_string, this) },
-        storage_{ client_.io_context(), tfc::base::make_config_file_name(key, "json"), std::forward<storage_type>(def) },
+        storage_{ ctx, tfc::base::make_config_file_name(key, "json"), std::forward<storage_type>(def) },
         logger_(fmt::format("config.{}", key)) {
-    client_.initialize();
-    storage_.on_change([]() {
-      // todo this can lead too callback hell, set property calls dbus set prop and dbus set prop calls back
-      //      client_.set(detail::config_property{ .value = string(), .schema = schema() });
-    });
+    init();
   }
 
   /// \brief construct config and deliver it to config manager
@@ -69,11 +70,7 @@ class config {
                  std::bind_front(&config::from_string, this) },
         storage_{ client_.io_context(), tfc::base::make_config_file_name(key, "json"), std::forward<storage_type>(def) },
         logger_(fmt::format("config.{}", key)) {
-    client_.initialize();
-    storage_.on_change([]() {
-      // todo this can lead too callback hell, set property calls dbus set prop and dbus set prop calls back
-      //      client_.set(detail::config_property{ .value = string(), .schema = schema() });
-    });
+    init();
   }
 
   /// \brief Advanced constructor providing file storage interface and dbus client
@@ -136,6 +133,14 @@ class config {
   }
 
 protected:
+  void init() {
+    client_.initialize();
+    storage_.on_change([]() {
+      // todo this can lead too callback hell, set property calls dbus set prop and dbus set prop calls back
+      //      client_.set(detail::config_property{ .value = string(), .schema = schema() });
+    });
+  }
+
   friend struct detail::change<config>;
 
   // todo if this could be named `value` it would be neat
diff --git a/libs/confman/inc/public/tfc/confman/detail/config_dbus_client.hpp b/libs/confman/inc/public/tfc/confman/detail/config_dbus_client.hpp
index c0e3d3a56b..e2a9160c99 100644
--- a/libs/confman/inc/public/tfc/confman/detail/config_dbus_client.hpp
+++ b/libs/confman/inc/public/tfc/confman/detail/config_dbus_client.hpp
@@ -2,7 +2,9 @@
 
 #include <filesystem>
 #include <functional>
+#include <memory>
 #include <string_view>
+#include <system_error>
 
 #include <tfc/dbus/sdbusplus_fwd.hpp>
 #include <tfc/stx/to_tuple.hpp>
@@ -30,6 +32,7 @@ struct config_property {
 
 namespace dbus {
 static constexpr std::string_view property_name{ "config" };
+static constexpr std::string_view config_path{ "Config" };
 }
 
 class config_dbus_client {
@@ -44,9 +47,15 @@ class config_dbus_client {
   using value_call_t = std::function<std::string()>;
   using schema_call_t = std::function<std::string()>;
   using change_call_t = std::function<std::error_code(std::string_view)>;
+  /// \brief make dbus client using io_context
+  /// Create a new dbus connection with a property named `config` using the given `key` to make interface name
   config_dbus_client(asio::io_context& ctx, std::string_view key, value_call_t&&, schema_call_t&&, change_call_t&&);
+  /// \brief make dbus client using given dbus connection
+  /// Create a property named `config` using the given `key` to make interface name
   config_dbus_client(dbus_connection_t conn, std::string_view key, value_call_t&&, schema_call_t&&, change_call_t&&);
-  config_dbus_client(interface_t intf, value_call_t&&, schema_call_t&&, change_call_t&&);
+  /// \brief make dbus client using given interface
+  /// Create a property with the given `key`
+  config_dbus_client(interface_t intf, std::string_view key, value_call_t&&, schema_call_t&&, change_call_t&&);
 
   void set(config_property&&) const;
 
@@ -55,6 +64,7 @@ class config_dbus_client {
 private:
   std::filesystem::path interface_path_{};
   std::string interface_name_{};
+  std::string property_name_{ dbus::property_name };
   value_call_t value_call_{};
   schema_call_t schema_call_{};
   change_call_t change_call_{};
diff --git a/libs/confman/src/detail/config_dbus_client.cpp b/libs/confman/src/detail/config_dbus_client.cpp
index 4025c1ffc9..83c9ea2ae8 100644
--- a/libs/confman/src/detail/config_dbus_client.cpp
+++ b/libs/confman/src/detail/config_dbus_client.cpp
@@ -1,3 +1,5 @@
+#include <utility>
+
 #include <tfc/confman/detail/config_dbus_client.hpp>
 #include <tfc/dbus/exception.hpp>
 #include <tfc/dbus/sd_bus.hpp>
@@ -18,10 +20,9 @@ namespace tfc::confman::detail {
 // busctl --system introspect com.skaginn3x.config.operation_mode.def.state_machine /com/skaginn3x/etc/tfc/config
 // clang-format on
 
-namespace dbus::tags {
-static constexpr std::string_view config{ "Config" };
-static constexpr std::string_view path{ tfc::dbus::const_dbus_path<config> };
-}  // namespace dbus::tags
+namespace dbus {
+static constexpr std::string_view path{ tfc::dbus::const_dbus_path<config_path> };
+}
 
 config_dbus_client::config_dbus_client(boost::asio::io_context& ctx) {}
 
@@ -30,9 +31,8 @@ config_dbus_client::config_dbus_client(dbus_connection_t conn,
                                        value_call_t&& value_call,
                                        schema_call_t&& schema_call,
                                        change_call_t&& change_call)
-    : interface_path_{ dbus::tags::path },
-      interface_name_{ tfc::dbus::make_dbus_name(
-          fmt::format("config.{}.{}.{}", base::get_exe_name(), base::get_proc_name(), key)) },
+    : interface_path_{ dbus::path }, interface_name_{ tfc::dbus::make_dbus_name(
+                                         fmt::format("config.{}.{}.{}", base::get_exe_name(), base::get_proc_name(), key)) },
       value_call_{ std::move(value_call) }, schema_call_{ std::move(schema_call) }, change_call_{ std::move(change_call) },
       dbus_connection_{ std::move(conn) }, dbus_interface_{
         std::make_unique<sdbusplus::asio::dbus_interface>(dbus_connection_, interface_path_.string(), interface_name_)
@@ -50,7 +50,12 @@ config_dbus_client::config_dbus_client(asio::io_context& ctx,
   dbus_connection_->request_name(interface_name_.c_str());
 }
 
-config_dbus_client::config_dbus_client(interface_t intf, value_call_t&&, schema_call_t&&, change_call_t&&) : dbus_interface_{ intf } {}
+config_dbus_client::config_dbus_client(interface_t intf,
+                                       std::string_view key,
+                                       value_call_t&&,
+                                       schema_call_t&&,
+                                       change_call_t&&)
+    : property_name_{ key }, dbus_interface_{ std::move(intf) } {}
 
 void config_dbus_client::set(config_property&& prop) const {
   if (dbus_interface_) {
@@ -61,7 +66,7 @@ void config_dbus_client::set(config_property&& prop) const {
 void config_dbus_client::initialize() {
   if (dbus_interface_) {
     dbus_interface_->register_property_rw<tfc::confman::detail::config_property>(
-        std::string{ dbus::property_name }, sdbusplus::vtable::property_::emits_change,
+        property_name_, sdbusplus::vtable::property_::emits_change,
         [this]([[maybe_unused]] config_property const& req, [[maybe_unused]] config_property& old) -> int {  // setter
           if (req == old) {
             return 1;

From ee29e427b444dd58835e53eccf38ece2ac0c3844 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=B3n=20Bjarni=20Bjarnason?= <jbbjarnason@gmail.com>
Date: Mon, 9 Oct 2023 08:30:47 +0000
Subject: [PATCH 06/33] exposing injectable dbus interface in confman

---
 libs/confman/inc/public/tfc/confman.hpp | 32 +++++++++++++++++++++----
 1 file changed, 28 insertions(+), 4 deletions(-)

diff --git a/libs/confman/inc/public/tfc/confman.hpp b/libs/confman/inc/public/tfc/confman.hpp
index 95b5c791f4..c48ba66bd0 100644
--- a/libs/confman/inc/public/tfc/confman.hpp
+++ b/libs/confman/inc/public/tfc/confman.hpp
@@ -34,18 +34,26 @@ class config {
   using type = config_storage_t;
   using storage_t = config_storage_t;
 
-  /// \brief construct config and deliver it to config manager
+  /// \brief construct config and expose it via dbus
   /// \param ctx context ref to which the config shall run in
   /// \param key identification of this config storage, requires to be unique
   config(asio::io_context& ctx, std::string_view key) : config{ ctx, key, config_storage_t{} } {}
 
-  /// \brief construct config and deliver it to config manager
+  /// \brief construct config and expose it via dbus
   /// \param conn valid dbus connection
   /// \param key identification of this config storage, requires to be unique
   config(std::shared_ptr<sdbusplus::asio::connection> conn, std::string_view key)
       : config{ conn, key, config_storage_t{} } {}
 
-  /// \brief construct config and deliver it to config manager
+  /// \brief construct config and expose it via dbus
+  /// \param interface valid dbus interface
+  /// \param key identification of this config storage, requires to be unique
+  /// \note the config will be accessible via dbus property on the `interface` using the given `key`
+  /// Take care that via this construction the frontend won't detect the config and show it automatically
+  config(std::shared_ptr<sdbusplus::asio::dbus_interface> interface, std::string_view key)
+      : config{ interface, key, config_storage_t{} } {}
+
+  /// \brief construct config and expose it via dbus
   /// \param ctx context ref to which the config shall run in
   /// \param key identification of this config storage, requires to be unique
   /// \param def default values of given storage type
@@ -59,7 +67,7 @@ class config {
     init();
   }
 
-  /// \brief construct config and deliver it to config manager
+  /// \brief construct config and expose it via dbus
   /// \param conn valid dbus connection
   /// \param key identification of this config storage, requires to be unique
   /// \param def default values of given storage type
@@ -73,6 +81,22 @@ class config {
     init();
   }
 
+  /// \brief construct config and expose it via dbus
+  /// \param interface valid dbus interface
+  /// \param key identification of this config storage, requires to be unique
+  /// \param def default values of given storage type
+  /// \note the config will be accessible via dbus property on the `interface` using the given `key`
+  /// Take care that via this construction the frontend won't detect the config and show it automatically
+  template <typename storage_type>
+    requires std::same_as<storage_t, std::remove_cvref_t<storage_type>>
+  config(std::shared_ptr<sdbusplus::asio::dbus_interface> interface, std::string_view key, storage_type&& def)
+      : client_{ interface, key, std::bind_front(&config::string, this), std::bind_front(&config::schema, this),
+                 std::bind_front(&config::from_string, this) },
+        storage_{ client_.io_context(), tfc::base::make_config_file_name(key, "json"), std::forward<storage_type>(def) },
+        logger_(fmt::format("config.{}", key)) {
+    init();
+  }
+
   /// \brief Advanced constructor providing file storage interface and dbus client
   /// \param key identification of this config storage, requires to be unique
   /// \param file_storage lvalue reference to file storage implementation

From 8944130eac0c5e9f2de3b50d9cfa92ddd1fb154f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=B3n=20Bjarni=20Bjarnason?= <jbbjarnason@gmail.com>
Date: Mon, 9 Oct 2023 09:02:09 +0000
Subject: [PATCH 07/33] wip moving new state detection to filter

---
 libs/ipc/inc/public/tfc/ipc.hpp               |  5 +-
 .../ipc/inc/public/tfc/ipc/details/filter.hpp | 69 ++++++++++++++++---
 libs/ipc/inc/public/tfc/ipc/details/impl.hpp  | 16 +----
 3 files changed, 67 insertions(+), 23 deletions(-)

diff --git a/libs/ipc/inc/public/tfc/ipc.hpp b/libs/ipc/inc/public/tfc/ipc.hpp
index 426e4c499c..39f3bd3d63 100644
--- a/libs/ipc/inc/public/tfc/ipc.hpp
+++ b/libs/ipc/inc/public/tfc/ipc.hpp
@@ -8,6 +8,7 @@
 #include <tfc/ipc/details/dbus_client_iface.hpp>
 #include <tfc/ipc/details/dbus_slot.hpp>
 #include <tfc/ipc/details/impl.hpp>
+#include <tfc/ipc/details/filter.hpp>
 #include <tfc/stx/concepts.hpp>
 
 namespace tfc::ipc {
@@ -60,7 +61,8 @@ class slot {
        std::string_view description,
        tfc::stx::invocable<value_t> auto&& callback)
     requires std::is_lvalue_reference_v<manager_client_type>
-      : slot_{ details::slot_callback<type_desc>::create(
+      : filters_{ ctx, fmt::format("{}.{}", type_desc::type_name, name), std::forward<decltype(callback)>(callback) },
+        slot_{ details::slot_callback<type_desc>::create(
             ctx,
             name,
             [this, callb = std::forward<decltype(callback)>(callback)](value_t const& new_value) {
@@ -119,6 +121,7 @@ class slot {
     dbus_slot_.initialize();
   }
 
+  filter::filters<value_t, std::function<void(value_t&)>> filters_;  // todo prefer some other type erasure mechanism
   std::shared_ptr<details::slot_callback<type_desc>> slot_;
   details::dbus_slot<value_t> dbus_slot_;
   manager_client_type client_;
diff --git a/libs/ipc/inc/public/tfc/ipc/details/filter.hpp b/libs/ipc/inc/public/tfc/ipc/details/filter.hpp
index 874ac45509..ead4476737 100644
--- a/libs/ipc/inc/public/tfc/ipc/details/filter.hpp
+++ b/libs/ipc/inc/public/tfc/ipc/details/filter.hpp
@@ -22,6 +22,7 @@ namespace asio = boost::asio;
 
 enum struct filter_e : std::uint8_t {
   unknown = 0,
+  new_state,
   invert,
   timer,
   offset,
@@ -44,6 +45,40 @@ enum struct filter_e : std::uint8_t {
 template <filter_e type, typename value_t, typename...>
 struct filter;
 
+template <typename value_t>
+  requires(!std::same_as<std::string, value_t>)
+struct filter<filter_e::new_state, value_t> {
+  static constexpr filter_e type{ filter_e::new_state };
+
+  auto async_process(value_t&& value, auto&& completion_token) const {
+    // todo can we get a compile error if executor is non-existent?
+    auto exe = asio::get_associated_executor(completion_token);
+    return asio::async_compose<decltype(completion_token), void(std::expected<bool, std::error_code>)>(
+        [this, moved = std::move(value)](auto& self) {
+          // clang-format off
+          PRAGMA_CLANG_WARNING_PUSH_OFF(-Wfloat-equal)
+          if (!last_value_.has_value() || moved != last_value_.value()) {
+          PRAGMA_CLANG_WARNING_POP
+            // clang-format on
+            last_value_.emplace(std::move(moved));
+            self.complete(last_value_.value());
+            return;
+          }
+          self.complete(std::unexpected{ std::make_error_code(std::errc::bad_message) });
+        },
+        completion_token, exe);
+  }
+
+  struct glaze {
+    using type = filter<filter_e::new_state, value_t>;
+    static constexpr std::string_view name{ "tfc::ipc::filter::new_state" };
+    static constexpr auto value{ &type::type };
+  };
+
+private:
+  mutable std::optional<value_t> last_value_{};
+};
+
 /// \brief behaviour flip the state of boolean
 template <>
 struct filter<filter_e::invert, bool> {
@@ -221,25 +256,33 @@ struct any_filter_decl;
 template <>
 struct any_filter_decl<bool> {
   using value_t = bool;
-  using type = std::variant<filter<filter_e::invert, value_t>, filter<filter_e::timer, value_t, std::chrono::steady_clock>>;
+  using type = std::variant<filter<filter_e::new_state, value_t>,
+                            filter<filter_e::invert, value_t>,
+                            filter<filter_e::timer, value_t, std::chrono::steady_clock>>;
 };
 template <>
 struct any_filter_decl<std::int64_t> {
   using value_t = std::int64_t;
-  using type = std::
-      variant<filter<filter_e::filter_out, value_t>, filter<filter_e::offset, value_t>, filter<filter_e::multiply, value_t>>;
+  using type = std::variant<filter<filter_e::new_state, value_t>,
+                            filter<filter_e::filter_out, value_t>,
+                            filter<filter_e::offset, value_t>,
+                            filter<filter_e::multiply, value_t>>;
 };
 template <>
 struct any_filter_decl<std::uint64_t> {
   using value_t = std::uint64_t;
-  using type = std::
-      variant<filter<filter_e::filter_out, value_t>, filter<filter_e::offset, value_t>, filter<filter_e::multiply, value_t>>;
+  using type = std::variant<filter<filter_e::new_state, value_t>,
+                            filter<filter_e::filter_out, value_t>,
+                            filter<filter_e::offset, value_t>,
+                            filter<filter_e::multiply, value_t>>;
 };
 template <>
 struct any_filter_decl<std::double_t> {
   using value_t = std::double_t;
-  using type = std::
-      variant<filter<filter_e::filter_out, value_t>, filter<filter_e::offset, value_t>, filter<filter_e::multiply, value_t>>;
+  using type = std::variant<filter<filter_e::new_state, value_t>,
+                            filter<filter_e::filter_out, value_t>,
+                            filter<filter_e::offset, value_t>,
+                            filter<filter_e::multiply, value_t>>;
 };
 template <>
 struct any_filter_decl<std::string> {
@@ -254,7 +297,16 @@ using any_filter_decl_t = any_filter_decl<value_t>::type;
 template <typename value_t, typename callback_t>
 class filters {
 public:
+  using config_t = std::vector<detail::any_filter_decl_t<value_t>>;
+
+  filters(asio::io_context& ctx, std::string_view name, callback_t&& callback)
+    requires std::is_trivial_v<value_t>
+      : ctx_{ ctx },
+        filters_{ ctx, fmt::format("{}._filters_", name), config_t{ { filter<filter_e::new_state, value_t>{} } } },
+        callback_{ callback } {}
+
   filters(asio::io_context& ctx, std::string_view name, callback_t&& callback)
+    requires std::same_as<std::string, value_t>
       : ctx_{ ctx }, filters_{ ctx, fmt::format("{}._filters_", name) }, callback_{ callback } {}
 
   /// \brief changes internal last_value state when filters have been processed
@@ -298,7 +350,7 @@ class filters {
 
 private:
   asio::io_context& ctx_;
-  tfc::confman::config<std::vector<detail::any_filter_decl_t<value_t>>> filters_;
+  tfc::confman::config<config_t> filters_;
   callback_t callback_;
   std::optional<value_t> last_value_{};
 };
@@ -311,6 +363,7 @@ struct glz::meta<tfc::ipc::filter::filter_e> {
   static std::string_view constexpr name{ "ipc::filter::filter_e" };
   // clang-format off
   static auto constexpr value{ glz::enumerate("unknown", unknown,
+                                              "new_state", new_state, "Call caller only on new state",
                                               "invert", invert, "Invert outputting value",
                                               "timer", timer, "Timer on/off delay of boolean",
                                               "offset", offset, "Adds a constant value to each sensor value",
diff --git a/libs/ipc/inc/public/tfc/ipc/details/impl.hpp b/libs/ipc/inc/public/tfc/ipc/details/impl.hpp
index 2183494304..a37b256724 100644
--- a/libs/ipc/inc/public/tfc/ipc/details/impl.hpp
+++ b/libs/ipc/inc/public/tfc/ipc/details/impl.hpp
@@ -18,7 +18,6 @@
 #include <boost/system/error_code.hpp>
 
 #include <tfc/ipc/details/dbus_slot.hpp>
-#include <tfc/ipc/details/filter.hpp>
 #include <tfc/ipc/details/type_description.hpp>
 #include <tfc/ipc/enums.hpp>
 #include <tfc/ipc/packet.hpp>
@@ -306,7 +305,6 @@ class slot_callback : public std::enable_shared_from_this<slot_callback<type_des
     register_read();
     return {};
   }
-  [[nodiscard]] auto value() const noexcept -> std::optional<value_t> const& { return filters_.value(); }
 
   /**
    * @brief disconnect from signal
@@ -318,21 +316,12 @@ class slot_callback : public std::enable_shared_from_this<slot_callback<type_des
 
 private:
   slot_callback(asio::io_context& ctx, std::string_view name, tfc::stx::invocable<value_t> auto&& callback)
-      : slot_{ ctx, name },
-        filters_{ ctx, fmt::format("{}.{}", type_desc::type_name, name), std::forward<decltype(callback)>(callback) } {}
+      : slot_{ ctx, name } {}
   void async_new_state(std::expected<value_t, std::error_code> value) {
     if (!value) {
       return;
     }
-    // Don't retransmit transmitted things.
-    // clang-format off
-    auto const& last_value{ filters_.value() };
-    PRAGMA_CLANG_WARNING_PUSH_OFF(-Wfloat-equal)
-    if (!last_value.has_value() || value.value() != last_value) {
-    PRAGMA_CLANG_WARNING_POP
-      // clang-format on
-      filters_(std::move(value.value()));
-    }
+    filters_(std::move(value.value()));
     register_read();
   }
   void register_read() {
@@ -344,7 +333,6 @@ class slot_callback : public std::enable_shared_from_this<slot_callback<type_des
     });
   }
   slot<type_desc> slot_;
-  filter::filters<value_t, std::function<void(value_t&)>> filters_;  // todo prefer some other type erasure mechanism
 };
 
 template <typename return_t, template <typename description_t> typename ipc_base_t>

From e106cb34bd8ef03dde9e9190c41fed0e64aa828d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=B3n=20Bjarni=20Bjarnason?= <jbbjarnason@gmail.com>
Date: Mon, 9 Oct 2023 13:07:45 +0000
Subject: [PATCH 08/33] wip moving new state detection to filter

---
 libs/ipc/inc/public/tfc/ipc.hpp               | 53 +++++++++-----
 .../ipc/inc/public/tfc/ipc/details/filter.hpp | 70 +++----------------
 libs/ipc/inc/public/tfc/ipc/details/impl.hpp  | 24 +++----
 3 files changed, 59 insertions(+), 88 deletions(-)

diff --git a/libs/ipc/inc/public/tfc/ipc.hpp b/libs/ipc/inc/public/tfc/ipc.hpp
index 39f3bd3d63..2acf085603 100644
--- a/libs/ipc/inc/public/tfc/ipc.hpp
+++ b/libs/ipc/inc/public/tfc/ipc.hpp
@@ -7,8 +7,8 @@
 #include <tfc/dbus/sdbusplus_fwd.hpp>
 #include <tfc/ipc/details/dbus_client_iface.hpp>
 #include <tfc/ipc/details/dbus_slot.hpp>
-#include <tfc/ipc/details/impl.hpp>
 #include <tfc/ipc/details/filter.hpp>
+#include <tfc/ipc/details/impl.hpp>
 #include <tfc/stx/concepts.hpp>
 
 namespace tfc::ipc {
@@ -61,16 +61,14 @@ class slot {
        std::string_view description,
        tfc::stx::invocable<value_t> auto&& callback)
     requires std::is_lvalue_reference_v<manager_client_type>
-      : filters_{ ctx, fmt::format("{}.{}", type_desc::type_name, name), std::forward<decltype(callback)>(callback) },
-        slot_{ details::slot_callback<type_desc>::create(
-            ctx,
-            name,
-            [this, callb = std::forward<decltype(callback)>(callback)](value_t const& new_value) {
-              callb(new_value);
-              dbus_slot_.emit_value(new_value);
-            }) },
+      : slot_{ details::slot_callback<type_desc>::create(ctx, name) },
         dbus_slot_{ client.connection(), full_name(), [this] -> std::optional<value_t> const& { return this->value(); } },
-        client_{ client } {
+        client_{ client }, filters_{ ctx, fmt::format("{}.{}", type_desc::type_name, name),
+                                     // store the callers callback in this lambda
+                                     [this, callb = std::forward<decltype(callback)>(callback)](value_t const& new_value) {
+                                       callb(new_value);
+                                       dbus_slot_.emit_value(new_value);
+                                     } } {
     client_init(description);
   }
 
@@ -87,7 +85,14 @@ class slot {
               callb(new_value);
               dbus_slot_.emit_value(new_value);
             }) },
-        dbus_slot_{ connection, full_name(), [this] -> std::optional<value_t> const& { return this->value(); } }, client_{ connection } {
+        dbus_slot_{ connection, full_name(), [this] -> std::optional<value_t> const& { return this->value(); } },
+        client_{ connection },
+        filters_{ ctx, fmt::format("{}.{}", type_desc::type_name, name),
+                  // store the callers callback in this lambda
+                  [this, callb = std::forward<decltype(callback)>(callback)](value_t const& new_value) {
+                    callb(new_value);
+                    dbus_slot_.emit_value(new_value);
+                  } } {
     client_init(description);
   }
 
@@ -105,7 +110,7 @@ class slot {
 
   auto operator=(slot const&) -> slot& = delete;
 
-  [[nodiscard]] auto value() const noexcept -> std::optional<value_t> const& { return slot_->value(); }
+  [[nodiscard]] auto value() const noexcept -> std::optional<value_t> const& { return filters_.value(); }
 
   [[nodiscard]] auto name() const noexcept -> std::string_view { return slot_->name(); }
 
@@ -113,18 +118,34 @@ class slot {
 
 private:
   void client_init(std::string_view description) {
-    client_.register_connection_change_callback(full_name(), [this](std::string_view signal_name) {
-      slot_->connect(signal_name);  //
-    });
+    auto new_state_filter = [this](value_t&& new_value) {
+      // Here we get unfiltered new value and test whether the value matches the current value
+      auto const& last_value = value();
+      // clang-format off
+      PRAGMA_CLANG_WARNING_PUSH_OFF(-Wfloat-equal)
+      if (!last_value.has_value() || new_value != last_value.value()) {
+      PRAGMA_CLANG_WARNING_POP
+        // clang-format on
+        this->filters_(std::move(new_value));
+        return;
+      }
+    };
+
+    client_.register_connection_change_callback(
+        full_name(),
+        // the following lambda takes ownership of the new_state_filter callback
+        // meaning if connection is changed the callback would not be thrown away
+        [this, callb = std::move(new_state_filter)](std::string_view signal_name) { slot_->connect(signal_name, callb); });
+
     client_.register_slot(full_name(), description, type_desc::value_e, details::register_cb(full_name()));
 
     dbus_slot_.initialize();
   }
 
-  filter::filters<value_t, std::function<void(value_t&)>> filters_;  // todo prefer some other type erasure mechanism
   std::shared_ptr<details::slot_callback<type_desc>> slot_;
   details::dbus_slot<value_t> dbus_slot_;
   manager_client_type client_;
+  filter::filters<value_t, std::function<void(value_t const&)>> filters_;
 };
 
 /**
diff --git a/libs/ipc/inc/public/tfc/ipc/details/filter.hpp b/libs/ipc/inc/public/tfc/ipc/details/filter.hpp
index ead4476737..e9d7280b61 100644
--- a/libs/ipc/inc/public/tfc/ipc/details/filter.hpp
+++ b/libs/ipc/inc/public/tfc/ipc/details/filter.hpp
@@ -45,40 +45,6 @@ enum struct filter_e : std::uint8_t {
 template <filter_e type, typename value_t, typename...>
 struct filter;
 
-template <typename value_t>
-  requires(!std::same_as<std::string, value_t>)
-struct filter<filter_e::new_state, value_t> {
-  static constexpr filter_e type{ filter_e::new_state };
-
-  auto async_process(value_t&& value, auto&& completion_token) const {
-    // todo can we get a compile error if executor is non-existent?
-    auto exe = asio::get_associated_executor(completion_token);
-    return asio::async_compose<decltype(completion_token), void(std::expected<bool, std::error_code>)>(
-        [this, moved = std::move(value)](auto& self) {
-          // clang-format off
-          PRAGMA_CLANG_WARNING_PUSH_OFF(-Wfloat-equal)
-          if (!last_value_.has_value() || moved != last_value_.value()) {
-          PRAGMA_CLANG_WARNING_POP
-            // clang-format on
-            last_value_.emplace(std::move(moved));
-            self.complete(last_value_.value());
-            return;
-          }
-          self.complete(std::unexpected{ std::make_error_code(std::errc::bad_message) });
-        },
-        completion_token, exe);
-  }
-
-  struct glaze {
-    using type = filter<filter_e::new_state, value_t>;
-    static constexpr std::string_view name{ "tfc::ipc::filter::new_state" };
-    static constexpr auto value{ &type::type };
-  };
-
-private:
-  mutable std::optional<value_t> last_value_{};
-};
-
 /// \brief behaviour flip the state of boolean
 template <>
 struct filter<filter_e::invert, bool> {
@@ -256,33 +222,25 @@ struct any_filter_decl;
 template <>
 struct any_filter_decl<bool> {
   using value_t = bool;
-  using type = std::variant<filter<filter_e::new_state, value_t>,
-                            filter<filter_e::invert, value_t>,
-                            filter<filter_e::timer, value_t, std::chrono::steady_clock>>;
+  using type = std::variant<filter<filter_e::invert, value_t>, filter<filter_e::timer, value_t, std::chrono::steady_clock>>;
 };
 template <>
 struct any_filter_decl<std::int64_t> {
   using value_t = std::int64_t;
-  using type = std::variant<filter<filter_e::new_state, value_t>,
-                            filter<filter_e::filter_out, value_t>,
-                            filter<filter_e::offset, value_t>,
-                            filter<filter_e::multiply, value_t>>;
+  using type = std::
+      variant<filter<filter_e::filter_out, value_t>, filter<filter_e::offset, value_t>, filter<filter_e::multiply, value_t>>;
 };
 template <>
 struct any_filter_decl<std::uint64_t> {
   using value_t = std::uint64_t;
-  using type = std::variant<filter<filter_e::new_state, value_t>,
-                            filter<filter_e::filter_out, value_t>,
-                            filter<filter_e::offset, value_t>,
-                            filter<filter_e::multiply, value_t>>;
+  using type = std::
+      variant<filter<filter_e::filter_out, value_t>, filter<filter_e::offset, value_t>, filter<filter_e::multiply, value_t>>;
 };
 template <>
 struct any_filter_decl<std::double_t> {
   using value_t = std::double_t;
-  using type = std::variant<filter<filter_e::new_state, value_t>,
-                            filter<filter_e::filter_out, value_t>,
-                            filter<filter_e::offset, value_t>,
-                            filter<filter_e::multiply, value_t>>;
+  using type = std::
+      variant<filter<filter_e::filter_out, value_t>, filter<filter_e::offset, value_t>, filter<filter_e::multiply, value_t>>;
 };
 template <>
 struct any_filter_decl<std::string> {
@@ -294,20 +252,14 @@ template <typename value_t>
 using any_filter_decl_t = any_filter_decl<value_t>::type;
 }  // namespace detail
 
-template <typename value_t, typename callback_t>
+template <typename value_t, tfc::stx::invocable<value_t> callback_t>
 class filters {
 public:
   using config_t = std::vector<detail::any_filter_decl_t<value_t>>;
 
-  filters(asio::io_context& ctx, std::string_view name, callback_t&& callback)
-    requires std::is_trivial_v<value_t>
-      : ctx_{ ctx },
-        filters_{ ctx, fmt::format("{}._filters_", name), config_t{ { filter<filter_e::new_state, value_t>{} } } },
-        callback_{ callback } {}
-
-  filters(asio::io_context& ctx, std::string_view name, callback_t&& callback)
-    requires std::same_as<std::string, value_t>
-      : ctx_{ ctx }, filters_{ ctx, fmt::format("{}._filters_", name) }, callback_{ callback } {}
+  filters(asio::io_context& ctx, std::string_view name, tfc::stx::invocable<value_t> auto&& callback)
+      : ctx_{ ctx }, filters_{ ctx, fmt::format("{}._filters_", name) },
+        callback_{ std::forward<decltype(callback)>(callback) } {}
 
   /// \brief changes internal last_value state when filters have been processed
   void operator()(value_t&& value) {
diff --git a/libs/ipc/inc/public/tfc/ipc/details/impl.hpp b/libs/ipc/inc/public/tfc/ipc/details/impl.hpp
index a37b256724..9f2ed3113e 100644
--- a/libs/ipc/inc/public/tfc/ipc/details/impl.hpp
+++ b/libs/ipc/inc/public/tfc/ipc/details/impl.hpp
@@ -290,19 +290,17 @@ class slot_callback : public std::enable_shared_from_this<slot_callback<type_des
   using value_t = type_desc::value_t;
   static auto constexpr direction_v = slot<type_desc>::direction_v;
 
-  [[nodiscard]] static auto create(asio::io_context& ctx,
-                                   std::string_view name,
-                                   tfc::stx::invocable<value_t> auto&& callback)
+  [[nodiscard]] static auto create(asio::io_context& ctx, std::string_view name)
       -> std::shared_ptr<slot_callback<type_desc>> {
     return std::shared_ptr<slot_callback<type_desc>>(
-        new slot_callback<type_desc>{ ctx, name, std::forward<decltype(callback)>(callback) });
+        new slot_callback<type_desc>{ ctx, name });
   }
 
-  auto connect(std::string_view signal_name) -> std::error_code {
+  auto connect(std::string_view signal_name, tfc::stx::invocable<value_t> auto&& callback) -> std::error_code {
     if (auto error = slot_.connect(signal_name)) {
       return error;
     }
-    register_read();
+    register_read(std::forward<decltype(callback)>(callback));
     return {};
   }
 
@@ -315,20 +313,20 @@ class slot_callback : public std::enable_shared_from_this<slot_callback<type_des
   [[nodiscard]] auto name_w_type() const -> std::string { return slot_.name_w_type(); }
 
 private:
-  slot_callback(asio::io_context& ctx, std::string_view name, tfc::stx::invocable<value_t> auto&& callback)
+  slot_callback(asio::io_context& ctx, std::string_view name)
       : slot_{ ctx, name } {}
-  void async_new_state(std::expected<value_t, std::error_code> value) {
+  void async_new_state(std::expected<value_t, std::error_code> value, tfc::stx::invocable<value_t> auto&& callback) {
     if (!value) {
       return;
     }
-    filters_(std::move(value.value()));
-    register_read();
+    callback(std::move(value.value()));
+    register_read(std::forward<decltype(callback)>(callback));
   }
-  void register_read() {
+  void register_read(tfc::stx::invocable<value_t> auto&& callback) {
     auto bind_reference = std::enable_shared_from_this<slot_callback<type_desc>>::weak_from_this();
-    slot_.async_receive([bind_reference](std::expected<value_t, std::error_code> value) {
+    slot_.async_receive([bind_reference, callb = std::forward<decltype(callback)>(callback)](std::expected<value_t, std::error_code> value) mutable {
       if (auto sptr = bind_reference.lock()) {
-        sptr->async_new_state(value);
+        sptr->async_new_state(value, std::forward<decltype(callb)>(callb));
       }
     });
   }

From 8cee3501cb81bb35166d9754fe06c03bc02f34c2 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=B3n=20Bjarni=20Bjarnason?= <jbbjarnason@gmail.com>
Date: Mon, 9 Oct 2023 14:48:51 +0000
Subject: [PATCH 09/33] wip going out of scope

---
 libs/confman/inc/public/tfc/confman.hpp       |  2 +-
 .../tfc/confman/detail/config_dbus_client.hpp |  2 +
 .../confman/src/detail/config_dbus_client.cpp |  4 ++
 libs/ipc/inc/public/tfc/ipc.hpp               |  8 ++-
 .../inc/public/tfc/ipc/details/dbus_slot.hpp  | 11 +++-
 .../ipc/inc/public/tfc/ipc/details/filter.hpp | 13 ++++-
 ports/sdbusplus/async-option.patch            | 43 --------------
 .../sdbusplus/disable-boost-definitions.patch | 16 ------
 ports/sdbusplus/meson_options.txt             |  3 -
 ports/sdbusplus/portfile.cmake                | 46 ---------------
 ports/sdbusplus/usage                         |  4 --
 ports/sdbusplus/vcpkg.json                    | 26 ---------
 ports/tfc-framework/portfile.cmake            | 33 -----------
 ports/tfc-framework/vcpkg.json                | 56 -------------------
 vcpkg-configuration.json                      | 11 +++-
 vcpkg.json                                    |  1 +
 16 files changed, 41 insertions(+), 238 deletions(-)
 delete mode 100644 ports/sdbusplus/async-option.patch
 delete mode 100644 ports/sdbusplus/disable-boost-definitions.patch
 delete mode 100644 ports/sdbusplus/meson_options.txt
 delete mode 100644 ports/sdbusplus/portfile.cmake
 delete mode 100644 ports/sdbusplus/usage
 delete mode 100644 ports/sdbusplus/vcpkg.json
 delete mode 100644 ports/tfc-framework/portfile.cmake
 delete mode 100644 ports/tfc-framework/vcpkg.json

diff --git a/libs/confman/inc/public/tfc/confman.hpp b/libs/confman/inc/public/tfc/confman.hpp
index c48ba66bd0..86944e2d0b 100644
--- a/libs/confman/inc/public/tfc/confman.hpp
+++ b/libs/confman/inc/public/tfc/confman.hpp
@@ -92,7 +92,7 @@ class config {
   config(std::shared_ptr<sdbusplus::asio::dbus_interface> interface, std::string_view key, storage_type&& def)
       : client_{ interface, key, std::bind_front(&config::string, this), std::bind_front(&config::schema, this),
                  std::bind_front(&config::from_string, this) },
-        storage_{ client_.io_context(), tfc::base::make_config_file_name(key, "json"), std::forward<storage_type>(def) },
+        storage_{ client_.get_io_context(), tfc::base::make_config_file_name(key, "json"), std::forward<storage_type>(def) },
         logger_(fmt::format("config.{}", key)) {
     init();
   }
diff --git a/libs/confman/inc/public/tfc/confman/detail/config_dbus_client.hpp b/libs/confman/inc/public/tfc/confman/detail/config_dbus_client.hpp
index e2a9160c99..a48f6d8b7e 100644
--- a/libs/confman/inc/public/tfc/confman/detail/config_dbus_client.hpp
+++ b/libs/confman/inc/public/tfc/confman/detail/config_dbus_client.hpp
@@ -61,6 +61,8 @@ class config_dbus_client {
 
   void initialize();
 
+   auto get_io_context() const noexcept -> asio::io_context&;
+
 private:
   std::filesystem::path interface_path_{};
   std::string interface_name_{};
diff --git a/libs/confman/src/detail/config_dbus_client.cpp b/libs/confman/src/detail/config_dbus_client.cpp
index 83c9ea2ae8..47e20fe1db 100644
--- a/libs/confman/src/detail/config_dbus_client.cpp
+++ b/libs/confman/src/detail/config_dbus_client.cpp
@@ -87,4 +87,8 @@ void config_dbus_client::initialize() {
   }
 }
 
+auto config_dbus_client::get_io_context() const noexcept -> asio::io_context& {
+  return dbus_interface_->connection()->get_io_context();
+}
+
 }  // namespace tfc::confman::detail
diff --git a/libs/ipc/inc/public/tfc/ipc.hpp b/libs/ipc/inc/public/tfc/ipc.hpp
index 2acf085603..83fb817bb6 100644
--- a/libs/ipc/inc/public/tfc/ipc.hpp
+++ b/libs/ipc/inc/public/tfc/ipc.hpp
@@ -63,7 +63,7 @@ class slot {
     requires std::is_lvalue_reference_v<manager_client_type>
       : slot_{ details::slot_callback<type_desc>::create(ctx, name) },
         dbus_slot_{ client.connection(), full_name(), [this] -> std::optional<value_t> const& { return this->value(); } },
-        client_{ client }, filters_{ ctx, fmt::format("{}.{}", type_desc::type_name, name),
+        client_{ client }, filters_{ dbus_slot_.interface(),
                                      // store the callers callback in this lambda
                                      [this, callb = std::forward<decltype(callback)>(callback)](value_t const& new_value) {
                                        callb(new_value);
@@ -87,7 +87,7 @@ class slot {
             }) },
         dbus_slot_{ connection, full_name(), [this] -> std::optional<value_t> const& { return this->value(); } },
         client_{ connection },
-        filters_{ ctx, fmt::format("{}.{}", type_desc::type_name, name),
+        filters_{ dbus_slot_.interface(),
                   // store the callers callback in this lambda
                   [this, callb = std::forward<decltype(callback)>(callback)](value_t const& new_value) {
                     callb(new_value);
@@ -139,6 +139,10 @@ class slot {
 
     client_.register_slot(full_name(), description, type_desc::value_e, details::register_cb(full_name()));
 
+    dbus_slot_.on_set([this](value_t&& set_value){
+      this->filters_.set(std::move(set_value));
+    });
+
     dbus_slot_.initialize();
   }
 
diff --git a/libs/ipc/inc/public/tfc/ipc/details/dbus_slot.hpp b/libs/ipc/inc/public/tfc/ipc/details/dbus_slot.hpp
index 4eb57c6ec9..db925566a7 100644
--- a/libs/ipc/inc/public/tfc/ipc/details/dbus_slot.hpp
+++ b/libs/ipc/inc/public/tfc/ipc/details/dbus_slot.hpp
@@ -18,6 +18,7 @@ namespace asio = boost::asio;
 namespace dbus::tags {
 static constexpr std::string_view value{ "Value" };
 static constexpr std::string_view slot{ "Slots" };
+static constexpr std::string_view tinker{ "Tinker" };
 static constexpr std::string_view path{ tfc::dbus::const_dbus_path<slot> };
 }  // namespace dbus::tags
 
@@ -30,9 +31,7 @@ class dbus_slot {
       : interface_{ std::make_shared<sdbusplus::asio::dbus_interface>(conn,
                                                                       std::string{ dbus::tags::path },
                                                                       tfc::dbus::make_dbus_name(slot_name)) },
-        value_getter_{ std::forward<decltype(value_getter)>(value_getter) } {
-
-  }
+        value_getter_{ std::forward<decltype(value_getter)>(value_getter) } {}
   void initialize() {
     interface_->register_property_r<value_t>(std::string{ dbus::tags::value }, sdbusplus::vtable::property_::emits_change,
                                              [this]([[maybe_unused]] value_t& old_value) {
@@ -51,6 +50,12 @@ class dbus_slot {
     }
   }
 
+  void on_set(tfc::stx::invocable<value_t&&> auto&& callback) {
+    interface_->register_method(
+        std::string{ dbus::tags::tinker },
+        [callb = std::forward<decltype(callback)>(callback)](value_t const& set_value) { callb(value_t{ set_value }); });
+  }
+
 private:
   std::shared_ptr<sdbusplus::asio::dbus_interface> interface_{};
   std::function<std::optional<value_t> const&()> value_getter_{};
diff --git a/libs/ipc/inc/public/tfc/ipc/details/filter.hpp b/libs/ipc/inc/public/tfc/ipc/details/filter.hpp
index e9d7280b61..c96b27bb91 100644
--- a/libs/ipc/inc/public/tfc/ipc/details/filter.hpp
+++ b/libs/ipc/inc/public/tfc/ipc/details/filter.hpp
@@ -3,7 +3,6 @@
 #include <expected>
 #include <vector>
 
-#include <fmt/core.h>
 #include <boost/asio/async_result.hpp>
 #include <boost/asio/co_spawn.hpp>
 #include <boost/asio/compose.hpp>
@@ -15,6 +14,7 @@
 #include <tfc/confman.hpp>
 #include <tfc/stx/glaze_meta.hpp>
 #include <tfc/utils/pragmas.hpp>
+#include <tfc/dbus/sdbusplus_fwd.hpp>
 
 namespace tfc::ipc::filter {
 
@@ -257,8 +257,8 @@ class filters {
 public:
   using config_t = std::vector<detail::any_filter_decl_t<value_t>>;
 
-  filters(asio::io_context& ctx, std::string_view name, tfc::stx::invocable<value_t> auto&& callback)
-      : ctx_{ ctx }, filters_{ ctx, fmt::format("{}._filters_", name) },
+  filters(std::shared_ptr<sdbusplus::asio::dbus_interface> interface, tfc::stx::invocable<value_t> auto&& callback)
+      : ctx_{ interface->connection()->get_io_context() }, filters_{ interface, "filter" },
         callback_{ std::forward<decltype(callback)>(callback) } {}
 
   /// \brief changes internal last_value state when filters have been processed
@@ -298,6 +298,13 @@ class filters {
           }
         });
   }
+
+  /// \brief bypass filters and set value directly
+  void set(value_t&& value) {
+    last_value_ = std::move(value);
+    std::invoke(callback_, last_value_.value());
+  }
+
   [[nodiscard]] auto value() const noexcept -> std::optional<value_t> const& { return last_value_; }
 
 private:
diff --git a/ports/sdbusplus/async-option.patch b/ports/sdbusplus/async-option.patch
deleted file mode 100644
index b30054db8d..0000000000
--- a/ports/sdbusplus/async-option.patch
+++ /dev/null
@@ -1,43 +0,0 @@
-diff --git a/meson.build b/meson.build
-index 52e330a..674bda9 100644
---- a/meson.build
-+++ b/meson.build
-@@ -6,9 +6,9 @@ project('sdbusplus', 'cpp', 'c',
-       'werror=true',
-       'tests=' + (meson.is_subproject() ? 'disabled' : 'auto'),
-       'examples=' + (meson.is_subproject() ? 'disabled' : 'auto'),
-+      'async=enabled',
-     ],
-     version: '1.0.0',
--    meson_version: '>=1.1.1',
- )
- 
- libsystemd_pkg = dependency('libsystemd')
-@@ -24,8 +24,6 @@ endif
- root_inc = include_directories('include')
- 
- libsdbusplus_src = files(
--    'src/async/context.cpp',
--    'src/async/match.cpp',
-     'src/bus.cpp',
-     'src/bus/match.cpp',
-     'src/event.cpp',
-@@ -36,6 +34,10 @@ libsdbusplus_src = files(
-     'src/server/transaction.cpp',
- )
- 
-+if get_option('async').enabled()
-+  libsdbusplus_src += files('src/async/context.cpp', 'src/async/match.cpp')
-+endif
-+
- libsdbusplus = library(
-     'sdbusplus',
-     libsdbusplus_src,
-diff --git a/meson.options b/meson.options
-index f4c22c4..7cc5965 100644
---- a/meson.options
-+++ b/meson.options
-@@ -1,2 +1,3 @@
- option('tests', type: 'feature', description: 'Build tests')
- option('examples', type: 'feature', description: 'Build examples')
-+option('async', type: 'feature', description: 'Build async interface')
diff --git a/ports/sdbusplus/disable-boost-definitions.patch b/ports/sdbusplus/disable-boost-definitions.patch
deleted file mode 100644
index 3ded6d3a87..0000000000
--- a/ports/sdbusplus/disable-boost-definitions.patch
+++ /dev/null
@@ -1,16 +0,0 @@
-diff --git a/meson.build b/meson.build
-index 448d167..3002fa2 100644
---- a/meson.build
-+++ b/meson.build
-@@ -46,11 +46,6 @@ libsdbusplus = library(
- )
-
- boost_compile_args = [
--    '-DBOOST_ASIO_DISABLE_THREADS',
--    '-DBOOST_ALL_NO_LIB',
--    '-DBOOST_SYSTEM_NO_DEPRECATED',
--    '-DBOOST_ERROR_CODE_HEADER_ONLY',
--    '-DBOOST_COROUTINES_NO_DEPRECATION_WARNING',
- ]
-
- boost_dep = declare_dependency(
diff --git a/ports/sdbusplus/meson_options.txt b/ports/sdbusplus/meson_options.txt
deleted file mode 100644
index 7cc5965b4f..0000000000
--- a/ports/sdbusplus/meson_options.txt
+++ /dev/null
@@ -1,3 +0,0 @@
-option('tests', type: 'feature', description: 'Build tests')
-option('examples', type: 'feature', description: 'Build examples')
-option('async', type: 'feature', description: 'Build async interface')
diff --git a/ports/sdbusplus/portfile.cmake b/ports/sdbusplus/portfile.cmake
deleted file mode 100644
index 85a2eef413..0000000000
--- a/ports/sdbusplus/portfile.cmake
+++ /dev/null
@@ -1,46 +0,0 @@
-if(VCPKG_TARGET_IS_LINUX)
-  message("Warning: `sdbusplus` requires GCC 13+")
-endif()
-
-vcpkg_from_github(
-    OUT_SOURCE_PATH SOURCE_PATH
-    REPO openbmc/sdbusplus
-    REF f6e67e87893b531d527d60a24d192bb6327964ef
-    SHA512 12b23243affcf43460b916f05293eedf3cb3992177dc47a19424c3686058b8a11495509960b3fbb6c44fbbdd5686153d51eb6030c6cc816748a3811f0dbb0784
-    PATCHES
-      # disabling boost definitions that cannot be defined because if privately linked to this library in one place
-      # and use different definitions for boost asio in other places will produce sigsev fault
-      disable-boost-definitions.patch
-      async-option.patch
-)
-
-# Hack to work with old meson version
-file(COPY "${CMAKE_CURRENT_LIST_DIR}/meson_options.txt" DESTINATION "${SOURCE_PATH}")
-
-file(INSTALL "${CMAKE_CURRENT_LIST_DIR}/usage" DESTINATION "${CURRENT_PACKAGES_DIR}/share/${PORT}")
-
-x_vcpkg_get_python_packages(
-    PYTHON_VERSION "3"
-    PACKAGES mako pyyaml inflection
-)
-
-if ("asio-only" IN_LIST FEATURES)
-  set(USE_ASYNC disabled)
-else()
-  set(USE_ASYNC enabled)
-endif()
-
-vcpkg_configure_meson(
-    SOURCE_PATH "${SOURCE_PATH}"
-    OPTIONS
-      -Dtests=disabled
-      -Dexamples=disabled
-      -Dasync=${USE_ASYNC}
-      -Dcpp_std=c++20 # todo revert to c++23 when meson tool has been upgraded
-)
-
-vcpkg_install_meson()
-
-vcpkg_fixup_pkgconfig()
-
-vcpkg_install_copyright(FILE_LIST "${SOURCE_PATH}/LICENSE")
diff --git a/ports/sdbusplus/usage b/ports/sdbusplus/usage
deleted file mode 100644
index 708d580ce2..0000000000
--- a/ports/sdbusplus/usage
+++ /dev/null
@@ -1,4 +0,0 @@
-sdbusplus provides CMake targets via pkg-config:
-    find_package(PkgConfig REQUIRED)
-    pkg_check_modules(SDBUSPLUS REQUIRED IMPORTED_TARGET GLOBAL sdbusplus)
-    target_link_libraries(main PRIVATE PkgConfig::SDBUSPLUS)
diff --git a/ports/sdbusplus/vcpkg.json b/ports/sdbusplus/vcpkg.json
deleted file mode 100644
index 5fc455a22f..0000000000
--- a/ports/sdbusplus/vcpkg.json
+++ /dev/null
@@ -1,26 +0,0 @@
-{
-  "name": "sdbusplus",
-  "version-date": "2023-09-14",
-  "description": "The sdbusplus library builds on top of the sd-bus library to create a modern C++ API for D-Bus.",
-  "homepage": "https://github.com/openbmc/sdbusplus",
-  "license": "Apache-2.0",
-  "supports": "linux",
-  "dependencies": [
-    "boost-asio",
-    "boost-callable-traits",
-    "libsystemd",
-    {
-      "name": "vcpkg-get-python-packages",
-      "host": true
-    },
-    {
-      "name": "vcpkg-tool-meson",
-      "host": true
-    }
-  ],
-  "features": {
-    "asio-only": {
-      "description": "Use only boost asio for the event loop"
-    }
-  }
-}
diff --git a/ports/tfc-framework/portfile.cmake b/ports/tfc-framework/portfile.cmake
deleted file mode 100644
index 1b365839cd..0000000000
--- a/ports/tfc-framework/portfile.cmake
+++ /dev/null
@@ -1,33 +0,0 @@
-vcpkg_from_github(
-  OUT_SOURCE_PATH SOURCE_PATH
-  REPO skaginn3x/framework
-  REF ${VERSION}
-  SHA512 20478778c26e086b28b48d97839f28d949ea1cc80df1c30918d00e9de7d86bd434058a6ff098eca76dec88c56426a001daa2782f3e188b7162472b09fc1a0f64
-)
-
-if ("build-exes" IN_LIST FEATURES)
-  set(BUILD_EXES ON)
-else()
-  set(BUILD_EXES OFF)
-endif()
-
-vcpkg_cmake_configure(
-    SOURCE_PATH "${SOURCE_PATH}"
-    OPTIONS
-      -DBUILD_EXES=${BUILD_EXES}
-      -DBUILD_TESTING=OFF
-      -DBUILD_DOCS=OFF
-      -DBUILD_EXAMPLES=OFF
-)
-
-if (${BUILD_EXES})
-  vcpkg_cmake_install(ADD_BIN_TO_PATH)
-else ()
-  vcpkg_cmake_install()
-endif ()
-
-vcpkg_cmake_config_fixup(PACKAGE_NAME tfc)
-
-file(REMOVE_RECURSE "${CURRENT_PACKAGES_DIR}/debug/include")
-
-vcpkg_install_copyright(FILE_LIST "${SOURCE_PATH}/LICENSE")
diff --git a/ports/tfc-framework/vcpkg.json b/ports/tfc-framework/vcpkg.json
deleted file mode 100644
index 541385577a..0000000000
--- a/ports/tfc-framework/vcpkg.json
+++ /dev/null
@@ -1,56 +0,0 @@
-{
-  "name": "tfc-framework",
-  "version": "2023.10.1",
-  "dependencies": [
-    "async-mqtt",
-    "azmq",
-    "bext-sml",
-    "bext-ut",
-    "boost-asio",
-    "boost-program-options",
-    "boost-stacktrace",
-    "date",
-    "fmt",
-    "glaze",
-    "gtest",
-    {
-      "name": "libgpiod",
-      "features": [
-        "cxx-bindings"
-      ]
-    },
-    "magic-enum",
-    "mp-units",
-    "openssl",
-    "pcg",
-    "protobuf",
-    {
-      "name": "sdbusplus",
-      "features": [
-        "asio-only"
-      ]
-    },
-    "soem",
-    "spdlog",
-    "stduuid",
-    {
-      "name": "vcpkg-cmake",
-      "host": true
-    },
-    {
-      "name": "vcpkg-cmake-config",
-      "host": true
-    }
-  ],
-  "features": {
-    "build-exes": {
-      "description": "Build binaries and install them to sysroot"
-    }
-  },
-  "overrides": [
-    {
-      "name": "mp-units",
-      "version": "0.8.0"
-    }
-  ]
-}
diff --git a/vcpkg-configuration.json b/vcpkg-configuration.json
index 80eb78a685..6c68ae91cf 100644
--- a/vcpkg-configuration.json
+++ b/vcpkg-configuration.json
@@ -4,8 +4,15 @@
     "repository": "https://github.com/microsoft/vcpkg",
     "baseline": "be2d7f886aad895e282b59088a2dfca5f6e1c88a"
   },
-  "overlay-ports" : [
-    "./ports"
+  "registries": [
+    {
+      "kind": "git",
+      "repository": "https://github.com/skaginn3x/vcpkg-registry",
+      "baseline": "158a95b4f5741535452360cf3af74e0982612737",
+      "packages": [
+        "sdbusplus"
+      ]
+    }
   ],
   "overlay-triplets": [
     "./vcpkg-overlays/triplets"
diff --git a/vcpkg.json b/vcpkg.json
index 541385577a..0729573131 100644
--- a/vcpkg.json
+++ b/vcpkg.json
@@ -26,6 +26,7 @@
     "protobuf",
     {
       "name": "sdbusplus",
+      "version>=": "2023-09-14",
       "features": [
         "asio-only"
       ]

From 8a07d6b44330afa2f90c0a4936cc14188cf7fd03 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=B3n=20Bjarni=20Bjarnason?= <jbbjarnason@gmail.com>
Date: Mon, 9 Oct 2023 14:57:31 +0000
Subject: [PATCH 10/33] make it somewhat work

---
 libs/confman/src/detail/config_dbus_client.cpp | 6 +++++-
 libs/ipc/inc/public/tfc/ipc/details/filter.hpp | 2 +-
 2 files changed, 6 insertions(+), 2 deletions(-)

diff --git a/libs/confman/src/detail/config_dbus_client.cpp b/libs/confman/src/detail/config_dbus_client.cpp
index 47e20fe1db..47549cda6b 100644
--- a/libs/confman/src/detail/config_dbus_client.cpp
+++ b/libs/confman/src/detail/config_dbus_client.cpp
@@ -83,7 +83,11 @@ void config_dbus_client::initialize() {
           return { .value = this->value_call_(), .schema = this->schema_call_() };
         });
 
-    dbus_interface_->initialize();
+    // If the provided interface is created by this class we initialize it here,
+    // otherwise we assume it is taken care of elsewhere
+    if (!interface_name_.empty()) {
+      dbus_interface_->initialize();
+    }
   }
 }
 
diff --git a/libs/ipc/inc/public/tfc/ipc/details/filter.hpp b/libs/ipc/inc/public/tfc/ipc/details/filter.hpp
index c96b27bb91..49e101edd7 100644
--- a/libs/ipc/inc/public/tfc/ipc/details/filter.hpp
+++ b/libs/ipc/inc/public/tfc/ipc/details/filter.hpp
@@ -258,7 +258,7 @@ class filters {
   using config_t = std::vector<detail::any_filter_decl_t<value_t>>;
 
   filters(std::shared_ptr<sdbusplus::asio::dbus_interface> interface, tfc::stx::invocable<value_t> auto&& callback)
-      : ctx_{ interface->connection()->get_io_context() }, filters_{ interface, "filter" },
+      : ctx_{ interface->connection()->get_io_context() }, filters_{ interface, "Filter" },
         callback_{ std::forward<decltype(callback)>(callback) } {}
 
   /// \brief changes internal last_value state when filters have been processed

From 5967676603f9479445fe82383c96fdec6cee9e55 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=B3n=20Bjarni=20Bjarnason?= <jbbjarnason@gmail.com>
Date: Mon, 9 Oct 2023 15:05:58 +0000
Subject: [PATCH 11/33] fix incomplete code

---
 libs/confman/src/detail/config_dbus_client.cpp | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/libs/confman/src/detail/config_dbus_client.cpp b/libs/confman/src/detail/config_dbus_client.cpp
index 47549cda6b..04cd087dc8 100644
--- a/libs/confman/src/detail/config_dbus_client.cpp
+++ b/libs/confman/src/detail/config_dbus_client.cpp
@@ -52,10 +52,12 @@ config_dbus_client::config_dbus_client(asio::io_context& ctx,
 
 config_dbus_client::config_dbus_client(interface_t intf,
                                        std::string_view key,
-                                       value_call_t&&,
-                                       schema_call_t&&,
-                                       change_call_t&&)
-    : property_name_{ key }, dbus_interface_{ std::move(intf) } {}
+                                       value_call_t&& value_call,
+                                       schema_call_t&& schema_call,
+                                       change_call_t&& change_call)
+
+    : property_name_{ key }, value_call_{ std::move(value_call) }, schema_call_{ std::move(schema_call) },
+      change_call_{ std::move(change_call) }, dbus_interface_{ std::move(intf) } {}
 
 void config_dbus_client::set(config_property&& prop) const {
   if (dbus_interface_) {

From 395600318319082b69918cfc43c081dbcc5980c9 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=B3n=20Bjarni=20Bjarnason?= <jbbjarnason@gmail.com>
Date: Mon, 9 Oct 2023 15:14:58 +0000
Subject: [PATCH 12/33] fix compile errors

---
 .../operations_state_machine_owner_test.cpp   |  3 +-
 exes/tfcctl/src/tfcctl.cpp                    |  6 ++--
 libs/ipc/testing/tests/ipc_test.cpp           | 35 +++++++++----------
 3 files changed, 21 insertions(+), 23 deletions(-)

diff --git a/exes/operations/tests/operations_state_machine_owner_test.cpp b/exes/operations/tests/operations_state_machine_owner_test.cpp
index 9e36a258a3..dcbae9bbe2 100644
--- a/exes/operations/tests/operations_state_machine_owner_test.cpp
+++ b/exes/operations/tests/operations_state_machine_owner_test.cpp
@@ -68,7 +68,8 @@ struct state_machine_mock {
 
 struct test_instance {
   asio::io_context ctx{};
-  tfc::operation::state_machine_owner<tfc::ipc::mock_signal, tfc::ipc::mock_slot, state_machine_mock> owner{ ctx };
+  std::shared_ptr<sdbusplus::asio::connection> dbus{};
+  tfc::operation::state_machine_owner<tfc::ipc::mock_signal, tfc::ipc::mock_slot, state_machine_mock> owner{ ctx, dbus };
 };
 
 auto main(int argc, char** argv) -> int {
diff --git a/exes/tfcctl/src/tfcctl.cpp b/exes/tfcctl/src/tfcctl.cpp
index 2f65a5c59b..b5b9a2f1ce 100644
--- a/exes/tfcctl/src/tfcctl.cpp
+++ b/exes/tfcctl/src/tfcctl.cpp
@@ -102,7 +102,8 @@ auto main(int argc, char** argv) -> int {
         [signal_name, &in_logger]<typename receiver_t>(receiver_t&& receiver) {
           if constexpr (!std::same_as<std::monostate, std::remove_cvref_t<receiver_t>>) {
             in_logger.trace("Connecting to signal {}", signal_name);
-            auto error = receiver->connect(signal_name);
+            std::string sig{ signal_name };
+            auto error = receiver->connect(signal_name, [sig, &in_logger](auto const& val) { in_logger.info("{}: {}", sig, val); });
             if (error) {
               in_logger.warn("Failed to connect: {}", error.message());
             }
@@ -119,8 +120,7 @@ auto main(int argc, char** argv) -> int {
       if (type == ipc::details::type_e::unknown) {
         throw std::runtime_error{ fmt::format("Unknown typename in: {}\n", sig) };
       }
-      auto ipc{ ipc::details::make_any_slot_cb::make(type, ctx, slot_name,
-                                                     [sig, &logger](auto const& val) { logger.info("{}: {}", sig, val); }) };
+      auto ipc{ ipc::details::make_any_slot_cb::make(type, ctx, slot_name) };
       slot_connect(ipc, sig, logger);
       return ipc;
     }(signal_connect));
diff --git a/libs/ipc/testing/tests/ipc_test.cpp b/libs/ipc/testing/tests/ipc_test.cpp
index c37e0a9474..e6dc01487e 100644
--- a/libs/ipc/testing/tests/ipc_test.cpp
+++ b/libs/ipc/testing/tests/ipc_test.cpp
@@ -84,10 +84,9 @@ auto main(int argc, char** argv) -> int {
   "ipc stop receiver"_test = [] {
     asio::io_context ctx;
     auto sender = tfc::ipc::details::uint_signal_ptr::element_type::create(ctx, "name").value();
-    auto receiver = tfc::ipc::details::uint_slot_cb_ptr::element_type::create(
-        ctx, "name", [](auto val) { std::cout << val << std::endl; });
+    auto receiver = tfc::ipc::details::uint_slot_cb_ptr::element_type::create(ctx, "name");
 
-    receiver->connect(sender->name_w_type());
+    receiver->connect(sender->name_w_type(), [](auto val) { std::cout << val << std::endl; });
     asio::steady_timer verification_timer{ ctx };
     verification_timer.expires_after(std::chrono::milliseconds{ 1 });
     verification_timer.async_wait([&ctx, &sender](auto) {
@@ -109,16 +108,15 @@ auto main(int argc, char** argv) -> int {
 
     auto sender = tfc::ipc::details::uint_signal_ptr::element_type::create(ctx, "name").value();
     bool receiver_called{ false };
-    auto receiver = tfc::ipc::details::uint_slot_cb_ptr::element_type::create(
-        ctx, "unused", [&ctx, &receiver_called, &uint64_to_time_point](auto val) {
-          auto now{ std::chrono::high_resolution_clock::now() };
-          auto past{ uint64_to_time_point(val) };
-          auto duration_ns = std::chrono::duration_cast<std::chrono::nanoseconds>(now - past);
-          fmt::print("Round time took: {}\n", duration_ns);
-          receiver_called = true;
-          ctx.stop();
-        });
-    receiver->connect(sender->name_w_type());
+    auto receiver = tfc::ipc::details::uint_slot_cb_ptr::element_type::create(ctx, "unused");
+    receiver->connect(sender->name_w_type(), [&ctx, &receiver_called, &uint64_to_time_point](auto val) {
+      auto now{ std::chrono::high_resolution_clock::now() };
+      auto past{ uint64_to_time_point(val) };
+      auto duration_ns = std::chrono::duration_cast<std::chrono::nanoseconds>(now - past);
+      fmt::print("Round time took: {}\n", duration_ns);
+      receiver_called = true;
+      ctx.stop();
+    });
     asio::steady_timer timer{ ctx };
     timer.expires_after(std::chrono::milliseconds(1));
     timer.async_wait([&sender, &time_point_to_uint64](auto) {
@@ -133,12 +131,11 @@ auto main(int argc, char** argv) -> int {
   "code_example"_test = []() {
     auto ctx{ asio::io_context() };
     auto sender{ tfc::ipc::details::string_signal_ptr::element_type::create(ctx, "name").value() };
-    auto receiver{ tfc::ipc::details::string_slot_cb_ptr::element_type::create(ctx, "unused",
-                                                                               [&ctx](std::string const& value) {
-                                                                                 fmt::print("received: {}\n", value);
-                                                                                 ctx.stop();
-                                                                               }) };
-    receiver->connect(sender->name_w_type());
+    auto receiver{ tfc::ipc::details::string_slot_cb_ptr::element_type::create(ctx, "unused") };
+    receiver->connect(sender->name_w_type(), [&ctx](std::string const& value) {
+      fmt::print("received: {}\n", value);
+      ctx.stop();
+    });
     asio::steady_timer timer{ ctx };
     timer.expires_after(std::chrono::milliseconds(100));
     timer.async_wait([&sender](auto) { sender->send("hello-world"); });

From 7a562bd7ac8b715d26c84dd1f3589f3375fa6387 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=B3n=20Bjarni=20Bjarnason?= <jbbjarnason@gmail.com>
Date: Mon, 9 Oct 2023 15:21:56 +0000
Subject: [PATCH 13/33] add name to dbus connection

---
 libs/ipc/src/dbus_client_iface.cpp | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/libs/ipc/src/dbus_client_iface.cpp b/libs/ipc/src/dbus_client_iface.cpp
index bb21683d76..456e9d10ea 100644
--- a/libs/ipc/src/dbus_client_iface.cpp
+++ b/libs/ipc/src/dbus_client_iface.cpp
@@ -14,7 +14,10 @@
 namespace tfc::ipc_ruler {
 
 ipc_manager_client::ipc_manager_client(asio::io_context& ctx)
-    : ipc_manager_client(std::make_shared<sdbusplus::asio::connection>(ctx, tfc::dbus::sd_bus_open_system())) {}
+    : ipc_manager_client(std::make_shared<sdbusplus::asio::connection>(ctx, tfc::dbus::sd_bus_open_system())) {
+  // If the owner of this client does not supply dbus connection we assume we are the sole owner of the connection
+  connection_->request_name(tfc::dbus::make_dbus_process_name().c_str());
+}
 
 ipc_manager_client::ipc_manager_client(std::shared_ptr<sdbusplus::asio::connection> connection)
     : connection_match_rule_{ tfc::dbus::match::rules::make_match_rule<consts::ipc_ruler_service_name,

From 80f6aabf269558e0df6a62599347b826ef7b808e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=B3n=20Bjarni=20Bjarnason?= <jbbjarnason@gmail.com>
Date: Mon, 9 Oct 2023 15:26:32 +0000
Subject: [PATCH 14/33] add missing if stmt in cmake

---
 libs/stx/CMakeLists.txt | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/libs/stx/CMakeLists.txt b/libs/stx/CMakeLists.txt
index f420cb34f6..6edb76e147 100644
--- a/libs/stx/CMakeLists.txt
+++ b/libs/stx/CMakeLists.txt
@@ -25,4 +25,6 @@ target_link_libraries(stx
 include(tfc_install)
 tfc_install_lib(stx)
 
-add_subdirectory(tests)
+if (BUILD_TESTING)
+  add_subdirectory(tests)
+endif ()

From 4c4cde44c49deab6148681025d4c9eb39e41e5c2 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=B3n=20Bjarni=20Bjarnason?= <jbbjarnason@gmail.com>
Date: Mon, 9 Oct 2023 15:27:26 +0000
Subject: [PATCH 15/33] remove files

---
 .github/workflows/vcpkg-install-test.yml | 48 ------------------------
 vcpkg-test/readme.md                     | 19 ----------
 vcpkg-test/vcpkg-configuration.json      | 13 -------
 vcpkg-test/vcpkg.json                    | 14 -------
 4 files changed, 94 deletions(-)
 delete mode 100644 .github/workflows/vcpkg-install-test.yml
 delete mode 100644 vcpkg-test/readme.md
 delete mode 100644 vcpkg-test/vcpkg-configuration.json
 delete mode 100644 vcpkg-test/vcpkg.json

diff --git a/.github/workflows/vcpkg-install-test.yml b/.github/workflows/vcpkg-install-test.yml
deleted file mode 100644
index d43ddea638..0000000000
--- a/.github/workflows/vcpkg-install-test.yml
+++ /dev/null
@@ -1,48 +0,0 @@
-name: vcpkg install tfc-framework
-
-on:
-  push:
-    branches: [ "main" ]
-  pull_request:
-    branches: [ "main" ]
-
-env:
-  CONFIGURATION_DIRECTORY: ${{ github.workspace }}
-
-concurrency:
-  group: ${{ github.workflow }}-${{ github.ref }}
-  cancel-in-progress: true
-
-jobs:
-  build:
-    name: 'build and install'
-    runs-on: ubuntu-22.04
-    container: ghcr.io/skaginn3x/skaginn3x/framework/tfc-toolchain:sha-f8ab815
-    strategy:
-      fail-fast: false
-      matrix:
-        triplet: [x64-linux-gcc, x64-linux-clang, arm64-linux, x64-linux-gcc-dynamic, x64-linux-clang-dynamic]
-    steps:
-      - uses: actions/checkout@v3
-
-      - uses: lukka/get-cmake@latest
-      - name: Vcpkg install test
-        uses: lukka/run-vcpkg@v11
-        with:
-          runVcpkgInstall: true
-          vcpkgDirectory: '/opt/vcpkg'
-          vcpkgGitCommitId: 'be2d7f886aad895e282b59088a2dfca5f6e1c88a'
-          vcpkgJsonGlob: 'vcpkg-test/vcpkg.json'
-
-      - name: Upload vcpkg log
-        if: failure()
-        uses: actions/upload-artifact@v3
-        with:
-          name: vcpkg-build-fail-logs
-          path: /opt/vcpkg/**/*out.log
-      - name: Upload vcpkg log
-        if: failure()
-        uses: actions/upload-artifact@v3
-        with:
-          name: vcpkg-build-fail-logs
-          path: /opt/vcpkg/**/*err.log
diff --git a/vcpkg-test/readme.md b/vcpkg-test/readme.md
deleted file mode 100644
index 09748bbfeb..0000000000
--- a/vcpkg-test/readme.md
+++ /dev/null
@@ -1,19 +0,0 @@
-# Skaginn 3X vcpkg tests
-
-
-## When changing
-
-Run the following command after each changed commit:
-```bash
-$ mkdir scripts
-$ cp /opt/vcpkg/scripts/vcpkgTools.xml scripts/
-$ /opt/vcpkg/vcpkg x-add-version --all --vcpkg-root=$(pwd) --overwrite-version
-```
-
-## Testing
-
-```bash
-$ cd test
-$ rm .vcpkg-root # if exists
-$ /opt/vcpkg/vcpkg --triplet x64-linux-clang install # select your desired triplet
-```
diff --git a/vcpkg-test/vcpkg-configuration.json b/vcpkg-test/vcpkg-configuration.json
deleted file mode 100644
index 8a53fa0b49..0000000000
--- a/vcpkg-test/vcpkg-configuration.json
+++ /dev/null
@@ -1,13 +0,0 @@
-{
-  "default-registry": {
-    "kind": "git",
-    "repository": "https://github.com/microsoft/vcpkg",
-    "baseline": "be2d7f886aad895e282b59088a2dfca5f6e1c88a"
-  },
-  "overlay-triplets": [
-    "../vcpkg-overlays/triplets"
-  ],
-  "overlay-ports": [
-    "../ports"
-  ]
-}
diff --git a/vcpkg-test/vcpkg.json b/vcpkg-test/vcpkg.json
deleted file mode 100644
index d31bdce8c7..0000000000
--- a/vcpkg-test/vcpkg.json
+++ /dev/null
@@ -1,14 +0,0 @@
-{
-  "name": "test-install-of-tfc-framework",
-  "dependencies": [
-    {
-      "name": "vcpkg-cmake",
-      "host": true
-    },
-    {
-      "name": "vcpkg-cmake-config",
-      "host": true
-    },
-    "tfc-framework"
-  ]
-}

From 99399462ce5cbc3a7ea4c74b4bff1c55da417426 Mon Sep 17 00:00:00 2001
From: jbbjarnason <jbbjarnason@users.noreply.github.com>
Date: Mon, 9 Oct 2023 15:29:33 +0000
Subject: [PATCH 16/33] Committing clang-format changes

---
 exes/operations/inc/state_machine_owner.hpp              | 2 +-
 exes/tfcctl/src/tfcctl.cpp                               | 3 ++-
 libs/confman/inc/public/tfc/confman.hpp                  | 4 ++--
 .../inc/public/tfc/confman/detail/config_dbus_client.hpp | 4 ++--
 libs/ipc/inc/public/tfc/ipc.hpp                          | 4 +---
 libs/ipc/inc/public/tfc/ipc/details/filter.hpp           | 2 +-
 libs/ipc/inc/public/tfc/ipc/details/impl.hpp             | 9 ++++-----
 7 files changed, 13 insertions(+), 15 deletions(-)

diff --git a/exes/operations/inc/state_machine_owner.hpp b/exes/operations/inc/state_machine_owner.hpp
index aca4ad2449..6e85e97235 100644
--- a/exes/operations/inc/state_machine_owner.hpp
+++ b/exes/operations/inc/state_machine_owner.hpp
@@ -5,6 +5,7 @@
 #include <boost/sml.hpp>
 
 #include <tfc/confman.hpp>
+#include <tfc/dbus/sdbusplus_fwd.hpp>
 #include <tfc/ipc.hpp>
 #include <tfc/ipc/details/dbus_client_iface.hpp>
 #include <tfc/ipc/details/type_description.hpp>
@@ -13,7 +14,6 @@
 #include <tfc/stx/concepts.hpp>
 #include <tfc/utils/asio_fwd.hpp>
 #include <tfc/utils/pragmas.hpp>
-#include <tfc/dbus/sdbusplus_fwd.hpp>
 
 namespace tfc::operation {
 
diff --git a/exes/tfcctl/src/tfcctl.cpp b/exes/tfcctl/src/tfcctl.cpp
index b5b9a2f1ce..7d6f5d2b0d 100644
--- a/exes/tfcctl/src/tfcctl.cpp
+++ b/exes/tfcctl/src/tfcctl.cpp
@@ -103,7 +103,8 @@ auto main(int argc, char** argv) -> int {
           if constexpr (!std::same_as<std::monostate, std::remove_cvref_t<receiver_t>>) {
             in_logger.trace("Connecting to signal {}", signal_name);
             std::string sig{ signal_name };
-            auto error = receiver->connect(signal_name, [sig, &in_logger](auto const& val) { in_logger.info("{}: {}", sig, val); });
+            auto error =
+                receiver->connect(signal_name, [sig, &in_logger](auto const& val) { in_logger.info("{}: {}", sig, val); });
             if (error) {
               in_logger.warn("Failed to connect: {}", error.message());
             }
diff --git a/libs/confman/inc/public/tfc/confman.hpp b/libs/confman/inc/public/tfc/confman.hpp
index 86944e2d0b..ea203d7cf4 100644
--- a/libs/confman/inc/public/tfc/confman.hpp
+++ b/libs/confman/inc/public/tfc/confman.hpp
@@ -2,14 +2,14 @@
 
 #include <filesystem>
 #include <functional>
+#include <memory>
 #include <string>
 #include <string_view>
 #include <system_error>
 #include <type_traits>
-#include <memory>
 
-#include <glaze/glaze.hpp>
 #include <fmt/format.h>
+#include <glaze/glaze.hpp>
 
 #include <tfc/confman/detail/change.hpp>
 #include <tfc/confman/detail/config_dbus_client.hpp>
diff --git a/libs/confman/inc/public/tfc/confman/detail/config_dbus_client.hpp b/libs/confman/inc/public/tfc/confman/detail/config_dbus_client.hpp
index a48f6d8b7e..54634b50ff 100644
--- a/libs/confman/inc/public/tfc/confman/detail/config_dbus_client.hpp
+++ b/libs/confman/inc/public/tfc/confman/detail/config_dbus_client.hpp
@@ -33,7 +33,7 @@ struct config_property {
 namespace dbus {
 static constexpr std::string_view property_name{ "config" };
 static constexpr std::string_view config_path{ "Config" };
-}
+}  // namespace dbus
 
 class config_dbus_client {
 public:
@@ -61,7 +61,7 @@ class config_dbus_client {
 
   void initialize();
 
-   auto get_io_context() const noexcept -> asio::io_context&;
+  auto get_io_context() const noexcept -> asio::io_context&;
 
 private:
   std::filesystem::path interface_path_{};
diff --git a/libs/ipc/inc/public/tfc/ipc.hpp b/libs/ipc/inc/public/tfc/ipc.hpp
index 83fb817bb6..30d29b0d6a 100644
--- a/libs/ipc/inc/public/tfc/ipc.hpp
+++ b/libs/ipc/inc/public/tfc/ipc.hpp
@@ -139,9 +139,7 @@ class slot {
 
     client_.register_slot(full_name(), description, type_desc::value_e, details::register_cb(full_name()));
 
-    dbus_slot_.on_set([this](value_t&& set_value){
-      this->filters_.set(std::move(set_value));
-    });
+    dbus_slot_.on_set([this](value_t&& set_value) { this->filters_.set(std::move(set_value)); });
 
     dbus_slot_.initialize();
   }
diff --git a/libs/ipc/inc/public/tfc/ipc/details/filter.hpp b/libs/ipc/inc/public/tfc/ipc/details/filter.hpp
index 49e101edd7..a8dc1e434c 100644
--- a/libs/ipc/inc/public/tfc/ipc/details/filter.hpp
+++ b/libs/ipc/inc/public/tfc/ipc/details/filter.hpp
@@ -12,9 +12,9 @@
 #include <glaze/core/common.hpp>
 
 #include <tfc/confman.hpp>
+#include <tfc/dbus/sdbusplus_fwd.hpp>
 #include <tfc/stx/glaze_meta.hpp>
 #include <tfc/utils/pragmas.hpp>
-#include <tfc/dbus/sdbusplus_fwd.hpp>
 
 namespace tfc::ipc::filter {
 
diff --git a/libs/ipc/inc/public/tfc/ipc/details/impl.hpp b/libs/ipc/inc/public/tfc/ipc/details/impl.hpp
index 9f2ed3113e..429169fd99 100644
--- a/libs/ipc/inc/public/tfc/ipc/details/impl.hpp
+++ b/libs/ipc/inc/public/tfc/ipc/details/impl.hpp
@@ -292,8 +292,7 @@ class slot_callback : public std::enable_shared_from_this<slot_callback<type_des
 
   [[nodiscard]] static auto create(asio::io_context& ctx, std::string_view name)
       -> std::shared_ptr<slot_callback<type_desc>> {
-    return std::shared_ptr<slot_callback<type_desc>>(
-        new slot_callback<type_desc>{ ctx, name });
+    return std::shared_ptr<slot_callback<type_desc>>(new slot_callback<type_desc>{ ctx, name });
   }
 
   auto connect(std::string_view signal_name, tfc::stx::invocable<value_t> auto&& callback) -> std::error_code {
@@ -313,8 +312,7 @@ class slot_callback : public std::enable_shared_from_this<slot_callback<type_des
   [[nodiscard]] auto name_w_type() const -> std::string { return slot_.name_w_type(); }
 
 private:
-  slot_callback(asio::io_context& ctx, std::string_view name)
-      : slot_{ ctx, name } {}
+  slot_callback(asio::io_context& ctx, std::string_view name) : slot_{ ctx, name } {}
   void async_new_state(std::expected<value_t, std::error_code> value, tfc::stx::invocable<value_t> auto&& callback) {
     if (!value) {
       return;
@@ -324,7 +322,8 @@ class slot_callback : public std::enable_shared_from_this<slot_callback<type_des
   }
   void register_read(tfc::stx::invocable<value_t> auto&& callback) {
     auto bind_reference = std::enable_shared_from_this<slot_callback<type_desc>>::weak_from_this();
-    slot_.async_receive([bind_reference, callb = std::forward<decltype(callback)>(callback)](std::expected<value_t, std::error_code> value) mutable {
+    slot_.async_receive([bind_reference, callb = std::forward<decltype(callback)>(callback)](
+                            std::expected<value_t, std::error_code> value) mutable {
       if (auto sptr = bind_reference.lock()) {
         sptr->async_new_state(value, std::forward<decltype(callb)>(callb));
       }

From ca05f49aa0a241e9f8a804d1ab15edb724118670 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=B3n=20Bjarni=20Bjarnason?= <jbbjarnason@gmail.com>
Date: Mon, 9 Oct 2023 15:48:05 +0000
Subject: [PATCH 17/33] sonar being stupid

---
 libs/ipc/inc/public/tfc/ipc/details/impl.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/libs/ipc/inc/public/tfc/ipc/details/impl.hpp b/libs/ipc/inc/public/tfc/ipc/details/impl.hpp
index 429169fd99..3bb0016ce0 100644
--- a/libs/ipc/inc/public/tfc/ipc/details/impl.hpp
+++ b/libs/ipc/inc/public/tfc/ipc/details/impl.hpp
@@ -325,7 +325,7 @@ class slot_callback : public std::enable_shared_from_this<slot_callback<type_des
     slot_.async_receive([bind_reference, callb = std::forward<decltype(callback)>(callback)](
                             std::expected<value_t, std::error_code> value) mutable {
       if (auto sptr = bind_reference.lock()) {
-        sptr->async_new_state(value, std::forward<decltype(callb)>(callb));
+        sptr->async_new_state(value, std::forward<decltype(callback)>(callb));
       }
     });
   }

From f86e4d1f72da871badcba8b526d2474314b3e957 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=B3n=20Bjarni=20Bjarnason?= <jbbjarnason@gmail.com>
Date: Mon, 9 Oct 2023 15:51:18 +0000
Subject: [PATCH 18/33] me being stupid ?

---
 libs/ipc/inc/public/tfc/ipc/details/impl.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/libs/ipc/inc/public/tfc/ipc/details/impl.hpp b/libs/ipc/inc/public/tfc/ipc/details/impl.hpp
index 3bb0016ce0..bf0ad0bb7e 100644
--- a/libs/ipc/inc/public/tfc/ipc/details/impl.hpp
+++ b/libs/ipc/inc/public/tfc/ipc/details/impl.hpp
@@ -325,7 +325,7 @@ class slot_callback : public std::enable_shared_from_this<slot_callback<type_des
     slot_.async_receive([bind_reference, callb = std::forward<decltype(callback)>(callback)](
                             std::expected<value_t, std::error_code> value) mutable {
       if (auto sptr = bind_reference.lock()) {
-        sptr->async_new_state(value, std::forward<decltype(callback)>(callb));
+        sptr->async_new_state(value, std::forward(callb));
       }
     });
   }

From 210390883d49dc95d7064cd4f25f59f2f0c60de6 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=B3n=20Bjarni=20Bjarnason?= <jbbjarnason@gmail.com>
Date: Mon, 9 Oct 2023 15:52:16 +0000
Subject: [PATCH 19/33] nope sonar being stupid

---
 libs/ipc/inc/public/tfc/ipc/details/impl.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/libs/ipc/inc/public/tfc/ipc/details/impl.hpp b/libs/ipc/inc/public/tfc/ipc/details/impl.hpp
index bf0ad0bb7e..bc1c534271 100644
--- a/libs/ipc/inc/public/tfc/ipc/details/impl.hpp
+++ b/libs/ipc/inc/public/tfc/ipc/details/impl.hpp
@@ -325,7 +325,7 @@ class slot_callback : public std::enable_shared_from_this<slot_callback<type_des
     slot_.async_receive([bind_reference, callb = std::forward<decltype(callback)>(callback)](
                             std::expected<value_t, std::error_code> value) mutable {
       if (auto sptr = bind_reference.lock()) {
-        sptr->async_new_state(value, std::forward(callb));
+        sptr->async_new_state(value, std::forward<decltype(callb)>(callb)); //NOSONAR
       }
     });
   }

From d0a28631806ed635c126a80be21b4fb330da70a7 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=B3n=20Bjarni=20Bjarnason?= <jbbjarnason@gmail.com>
Date: Mon, 9 Oct 2023 15:52:41 +0000
Subject: [PATCH 20/33] format

---
 libs/ipc/inc/public/tfc/ipc/details/impl.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/libs/ipc/inc/public/tfc/ipc/details/impl.hpp b/libs/ipc/inc/public/tfc/ipc/details/impl.hpp
index bc1c534271..bcdd06275a 100644
--- a/libs/ipc/inc/public/tfc/ipc/details/impl.hpp
+++ b/libs/ipc/inc/public/tfc/ipc/details/impl.hpp
@@ -325,7 +325,7 @@ class slot_callback : public std::enable_shared_from_this<slot_callback<type_des
     slot_.async_receive([bind_reference, callb = std::forward<decltype(callback)>(callback)](
                             std::expected<value_t, std::error_code> value) mutable {
       if (auto sptr = bind_reference.lock()) {
-        sptr->async_new_state(value, std::forward<decltype(callb)>(callb)); //NOSONAR
+        sptr->async_new_state(value, std::forward<decltype(callb)>(callb));  // NOSONAR
       }
     });
   }

From 18f47cd2028d5737032ce3af31b6a3d96bcd624b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=B3n=20Bjarni=20Bjarnason?= <jbbjarnason@gmail.com>
Date: Tue, 10 Oct 2023 08:30:12 +0000
Subject: [PATCH 21/33] Exposing Type as json schema for ipc slots

---
 libs/ipc/inc/public/tfc/ipc/details/dbus_slot.hpp | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/libs/ipc/inc/public/tfc/ipc/details/dbus_slot.hpp b/libs/ipc/inc/public/tfc/ipc/details/dbus_slot.hpp
index db925566a7..0045ecc76f 100644
--- a/libs/ipc/inc/public/tfc/ipc/details/dbus_slot.hpp
+++ b/libs/ipc/inc/public/tfc/ipc/details/dbus_slot.hpp
@@ -10,6 +10,7 @@
 #include <tfc/dbus/string_maker.hpp>
 #include <tfc/ipc/details/dbus_slot.hpp>
 #include <tfc/stx/concepts.hpp>
+#include <tfc/utils/json_schema.hpp>
 
 namespace tfc::ipc::details {
 
@@ -19,6 +20,7 @@ namespace dbus::tags {
 static constexpr std::string_view value{ "Value" };
 static constexpr std::string_view slot{ "Slots" };
 static constexpr std::string_view tinker{ "Tinker" };
+static constexpr std::string_view type{ "Type" };
 static constexpr std::string_view path{ tfc::dbus::const_dbus_path<slot> };
 }  // namespace dbus::tags
 
@@ -40,6 +42,11 @@ class dbus_slot {
                                                }
                                                return value_t{};
                                              });
+    interface_->register_property_r<std::string>(std::string{ dbus::tags::type }, sdbusplus::vtable::property_::emits_change,
+                                             []([[maybe_unused]] std::string& old_value) {
+                                               return tfc::json::write_json_schema<value_t>();
+                                             });
+
     interface_->initialize();
   }
   auto interface() const noexcept -> std::shared_ptr<sdbusplus::asio::dbus_interface> { return interface_; }

From ef5e4ac1e611154a518b70e4800964c98e67b7e1 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=B3n=20Bjarni=20Bjarnason?= <jbbjarnason@gmail.com>
Date: Tue, 10 Oct 2023 09:08:34 +0000
Subject: [PATCH 22/33] new state filter works strictly on unfiltered raw value
 from signal

---
 libs/ipc/inc/public/tfc/ipc.hpp               | 18 +------
 .../inc/public/tfc/ipc/details/dbus_slot.hpp  |  7 ++-
 .../ipc/inc/public/tfc/ipc/details/filter.hpp | 14 ++++--
 libs/ipc/inc/public/tfc/ipc/details/impl.hpp  | 48 +++++++++++++++----
 4 files changed, 52 insertions(+), 35 deletions(-)

diff --git a/libs/ipc/inc/public/tfc/ipc.hpp b/libs/ipc/inc/public/tfc/ipc.hpp
index 30d29b0d6a..2691c7aa99 100644
--- a/libs/ipc/inc/public/tfc/ipc.hpp
+++ b/libs/ipc/inc/public/tfc/ipc.hpp
@@ -118,24 +118,8 @@ class slot {
 
 private:
   void client_init(std::string_view description) {
-    auto new_state_filter = [this](value_t&& new_value) {
-      // Here we get unfiltered new value and test whether the value matches the current value
-      auto const& last_value = value();
-      // clang-format off
-      PRAGMA_CLANG_WARNING_PUSH_OFF(-Wfloat-equal)
-      if (!last_value.has_value() || new_value != last_value.value()) {
-      PRAGMA_CLANG_WARNING_POP
-        // clang-format on
-        this->filters_(std::move(new_value));
-        return;
-      }
-    };
-
     client_.register_connection_change_callback(
-        full_name(),
-        // the following lambda takes ownership of the new_state_filter callback
-        // meaning if connection is changed the callback would not be thrown away
-        [this, callb = std::move(new_state_filter)](std::string_view signal_name) { slot_->connect(signal_name, callb); });
+        full_name(), [this](std::string_view signal_name) { slot_->connect(signal_name, filters_); });
 
     client_.register_slot(full_name(), description, type_desc::value_e, details::register_cb(full_name()));
 
diff --git a/libs/ipc/inc/public/tfc/ipc/details/dbus_slot.hpp b/libs/ipc/inc/public/tfc/ipc/details/dbus_slot.hpp
index 0045ecc76f..6b16ad1d1e 100644
--- a/libs/ipc/inc/public/tfc/ipc/details/dbus_slot.hpp
+++ b/libs/ipc/inc/public/tfc/ipc/details/dbus_slot.hpp
@@ -42,10 +42,9 @@ class dbus_slot {
                                                }
                                                return value_t{};
                                              });
-    interface_->register_property_r<std::string>(std::string{ dbus::tags::type }, sdbusplus::vtable::property_::emits_change,
-                                             []([[maybe_unused]] std::string& old_value) {
-                                               return tfc::json::write_json_schema<value_t>();
-                                             });
+    interface_->register_property_r<std::string>(
+        std::string{ dbus::tags::type }, sdbusplus::vtable::property_::emits_change,
+        []([[maybe_unused]] std::string& old_value) { return tfc::json::write_json_schema<value_t>(); });
 
     interface_->initialize();
   }
diff --git a/libs/ipc/inc/public/tfc/ipc/details/filter.hpp b/libs/ipc/inc/public/tfc/ipc/details/filter.hpp
index a8dc1e434c..2f7a6cbd69 100644
--- a/libs/ipc/inc/public/tfc/ipc/details/filter.hpp
+++ b/libs/ipc/inc/public/tfc/ipc/details/filter.hpp
@@ -262,13 +262,15 @@ class filters {
         callback_{ std::forward<decltype(callback)>(callback) } {}
 
   /// \brief changes internal last_value state when filters have been processed
-  void operator()(value_t&& value) {
+  void operator()(auto&& value)
+    requires std::same_as<std::remove_cvref_t<decltype(value)>, value_t>
+  {
     if (filters_->empty()) {
-      last_value_ = std::move(value);
+      last_value_ = std::forward<decltype(value)>(value);
       std::invoke(callback_, last_value_.value());
       return;
     }
-    std::expected<value_t, std::error_code> return_value{ std::move(value) };
+    std::expected<value_t, std::error_code> return_value{ std::forward<decltype(value)>(value) };
     asio::co_spawn(
         ctx_,
         [this, return_val = std::move(return_value)] mutable -> asio::awaitable<std::expected<value_t, std::error_code>> {
@@ -300,8 +302,10 @@ class filters {
   }
 
   /// \brief bypass filters and set value directly
-  void set(value_t&& value) {
-    last_value_ = std::move(value);
+  void set(auto&& value)
+    requires std::same_as<std::remove_cvref_t<decltype(value)>, value_t>
+  {
+    last_value_ = std::forward<decltype(value)>(value);
     std::invoke(callback_, last_value_.value());
   }
 
diff --git a/libs/ipc/inc/public/tfc/ipc/details/impl.hpp b/libs/ipc/inc/public/tfc/ipc/details/impl.hpp
index bcdd06275a..f1c15268ad 100644
--- a/libs/ipc/inc/public/tfc/ipc/details/impl.hpp
+++ b/libs/ipc/inc/public/tfc/ipc/details/impl.hpp
@@ -308,27 +308,57 @@ class slot_callback : public std::enable_shared_from_this<slot_callback<type_des
    */
   auto disconnect(std::string_view signal_name) { return slot_.disconnect(signal_name.data()); }
 
-  /// \return <type>.<name> for example: bool.my_name
+  [[nodiscard]] auto value() const -> std::optional<value_t> { return last_value_; }
+
+  [[nodiscard]] auto name() const noexcept -> std::string_view { return slot_.name(); }
+
   [[nodiscard]] auto name_w_type() const -> std::string { return slot_.name_w_type(); }
 
 private:
   slot_callback(asio::io_context& ctx, std::string_view name) : slot_{ ctx, name } {}
-  void async_new_state(std::expected<value_t, std::error_code> value, tfc::stx::invocable<value_t> auto&& callback) {
-    if (!value) {
+  void async_new_state(std::expected<value_t, std::error_code> new_value, tfc::stx::invocable<value_t> auto&& callback) {
+    if (!new_value) {
+      return;
+    }
+
+    // Here we get unfiltered new value and test whether the value matches the current value
+    auto const& last_value = value();
+    // clang-format off
+    PRAGMA_CLANG_WARNING_PUSH_OFF(-Wfloat-equal)
+    if (!last_value.has_value() || new_value.value() != last_value.value()) {
+    PRAGMA_CLANG_WARNING_POP
+      // clang-format on
+      last_value_ = std::move(new_value.value());
+      callback(last_value_.value());
       return;
     }
-    callback(std::move(value.value()));
+
     register_read(std::forward<decltype(callback)>(callback));
   }
   void register_read(tfc::stx::invocable<value_t> auto&& callback) {
     auto bind_reference = std::enable_shared_from_this<slot_callback<type_desc>>::weak_from_this();
-    slot_.async_receive([bind_reference, callb = std::forward<decltype(callback)>(callback)](
-                            std::expected<value_t, std::error_code> value) mutable {
-      if (auto sptr = bind_reference.lock()) {
-        sptr->async_new_state(value, std::forward<decltype(callb)>(callb));  // NOSONAR
+
+    if constexpr (std::is_lvalue_reference_v<decltype(callback)>) {
+      slot_.async_receive([bind_reference, &callback](std::expected<value_t, std::error_code>&& value) mutable {
+        if (auto sptr = bind_reference.lock()) {
+          sptr->async_new_state(value, std::forward<decltype(callback)>(callback));
+        }
+      });
+    } else if constexpr (std::is_rvalue_reference_v<decltype(callback)>) {
+      slot_.async_receive(
+          [bind_reference, callb = std::move(callback)](std::expected<value_t, std::error_code>&& value) mutable {
+            if (auto sptr = bind_reference.lock()) {
+              sptr->async_new_state(value, std::move(callb));
+            }
+          });
+    } else {
+      []<bool flag = false> {
+        static_assert(flag, "Invalid typeof callback");
       }
-    });
+      ();
+    }
   }
+  std::optional<value_t> last_value_{ std::nullopt };
   slot<type_desc> slot_;
 };
 

From bb30e1c3957db00d0d8210bba8ad2659767d4806 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=B3n=20Bjarni=20Bjarnason?= <jbbjarnason@gmail.com>
Date: Tue, 10 Oct 2023 09:09:56 +0000
Subject: [PATCH 23/33] add getter for unfiltered value

---
 libs/ipc/inc/public/tfc/ipc.hpp | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/libs/ipc/inc/public/tfc/ipc.hpp b/libs/ipc/inc/public/tfc/ipc.hpp
index 2691c7aa99..ed791aaf6e 100644
--- a/libs/ipc/inc/public/tfc/ipc.hpp
+++ b/libs/ipc/inc/public/tfc/ipc.hpp
@@ -112,6 +112,8 @@ class slot {
 
   [[nodiscard]] auto value() const noexcept -> std::optional<value_t> const& { return filters_.value(); }
 
+  [[nodiscard]] auto unfiltered_value() const noexcept -> std::optional<value_t> const& { return slot_.value(); }
+
   [[nodiscard]] auto name() const noexcept -> std::string_view { return slot_->name(); }
 
   [[nodiscard]] auto full_name() const noexcept -> std::string { return slot_->name_w_type(); }

From b92f098f3dc9c2e65bb5b7ed89e22cd842990296 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=B3n=20Bjarni=20Bjarnason?= <jbbjarnason@gmail.com>
Date: Tue, 10 Oct 2023 09:18:45 +0000
Subject: [PATCH 24/33] fix gcc warning

---
 libs/confman/src/detail/config_dbus_client.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/libs/confman/src/detail/config_dbus_client.cpp b/libs/confman/src/detail/config_dbus_client.cpp
index 04cd087dc8..35eac47f72 100644
--- a/libs/confman/src/detail/config_dbus_client.cpp
+++ b/libs/confman/src/detail/config_dbus_client.cpp
@@ -24,7 +24,7 @@ namespace dbus {
 static constexpr std::string_view path{ tfc::dbus::const_dbus_path<config_path> };
 }
 
-config_dbus_client::config_dbus_client(boost::asio::io_context& ctx) {}
+config_dbus_client::config_dbus_client(boost::asio::io_context&) {}
 
 config_dbus_client::config_dbus_client(dbus_connection_t conn,
                                        std::string_view key,

From 3fc29f195d21dda93f75f5e8531d0dfdc25f8139 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=B3n=20Bjarni=20Bjarnason?= <jbbjarnason@gmail.com>
Date: Tue, 10 Oct 2023 09:38:50 +0000
Subject: [PATCH 25/33] disable sonar

---
 libs/ipc/inc/public/tfc/ipc/details/impl.hpp | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/libs/ipc/inc/public/tfc/ipc/details/impl.hpp b/libs/ipc/inc/public/tfc/ipc/details/impl.hpp
index f1c15268ad..6c4da0e229 100644
--- a/libs/ipc/inc/public/tfc/ipc/details/impl.hpp
+++ b/libs/ipc/inc/public/tfc/ipc/details/impl.hpp
@@ -345,12 +345,12 @@ class slot_callback : public std::enable_shared_from_this<slot_callback<type_des
         }
       });
     } else if constexpr (std::is_rvalue_reference_v<decltype(callback)>) {
-      slot_.async_receive(
-          [bind_reference, callb = std::move(callback)](std::expected<value_t, std::error_code>&& value) mutable {
-            if (auto sptr = bind_reference.lock()) {
-              sptr->async_new_state(value, std::move(callb));
-            }
-          });
+      slot_.async_receive([bind_reference, callb = std::move(callback)](
+                              std::expected<value_t, std::error_code>&& value) mutable {  // NOSONAR
+        if (auto sptr = bind_reference.lock()) {
+          sptr->async_new_state(value, std::move(callb));
+        }
+      });
     } else {
       []<bool flag = false> {
         static_assert(flag, "Invalid typeof callback");

From 3e444f0daf22509f8af302a600bfed9cd6d65ab6 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=B3n=20Bjarni=20Bjarnason?= <jbbjarnason@gmail.com>
Date: Tue, 10 Oct 2023 09:40:43 +0000
Subject: [PATCH 26/33] move disable sonar

---
 libs/ipc/inc/public/tfc/ipc/details/impl.hpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/libs/ipc/inc/public/tfc/ipc/details/impl.hpp b/libs/ipc/inc/public/tfc/ipc/details/impl.hpp
index 6c4da0e229..4e3159d7ba 100644
--- a/libs/ipc/inc/public/tfc/ipc/details/impl.hpp
+++ b/libs/ipc/inc/public/tfc/ipc/details/impl.hpp
@@ -345,8 +345,8 @@ class slot_callback : public std::enable_shared_from_this<slot_callback<type_des
         }
       });
     } else if constexpr (std::is_rvalue_reference_v<decltype(callback)>) {
-      slot_.async_receive([bind_reference, callb = std::move(callback)](
-                              std::expected<value_t, std::error_code>&& value) mutable {  // NOSONAR
+      slot_.async_receive([bind_reference, callb = std::move(callback)](  // NOSONAR
+                              std::expected<value_t, std::error_code>&& value) mutable {
         if (auto sptr = bind_reference.lock()) {
           sptr->async_new_state(value, std::move(callb));
         }

From 71dce6ca44a34fba431773ca5fc1f4b42525014a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=B3n=20Bjarni=20Bjarnason?= <jbbjarnason@gmail.com>
Date: Tue, 10 Oct 2023 09:49:10 +0000
Subject: [PATCH 27/33] fix tests

---
 exes/ethercat/tests/devices/beckhoff.cpp                    | 2 +-
 libs/ipc/CMakeLists.txt                                     | 2 +-
 .../inc/public/tfc/ipc/details/dbus_client_iface_mock.hpp   | 2 --
 ...bus_server_iface_mock.cpp => dbus_client_iface_mock.cpp} | 0
 libs/ipc/testing/tests/ipc_manager_test.cpp                 | 6 +++---
 5 files changed, 5 insertions(+), 7 deletions(-)
 rename libs/ipc/src/{dbus_server_iface_mock.cpp => dbus_client_iface_mock.cpp} (100%)

diff --git a/exes/ethercat/tests/devices/beckhoff.cpp b/exes/ethercat/tests/devices/beckhoff.cpp
index 8556876e25..6d89117364 100644
--- a/exes/ethercat/tests/devices/beckhoff.cpp
+++ b/exes/ethercat/tests/devices/beckhoff.cpp
@@ -22,7 +22,7 @@ using ut::expect;
 template <typename device_t>
 struct test_vars {
   asio::io_context ctx{};
-  ipc_manager_client_mock connect_interface{};
+  ipc_manager_client_mock connect_interface{ ctx };
   device_t device;
 };
 auto main(int argc, const char* argv[]) -> int {
diff --git a/libs/ipc/CMakeLists.txt b/libs/ipc/CMakeLists.txt
index 2270110cad..ef81c4ccd0 100644
--- a/libs/ipc/CMakeLists.txt
+++ b/libs/ipc/CMakeLists.txt
@@ -3,7 +3,7 @@ cmake_minimum_required(VERSION 3.21)
 
 add_library(ipc
   src/ipc.cpp
-  src/dbus_server_iface_mock.cpp # todo make ipc_test target
+    src/dbus_client_iface_mock.cpp # todo make ipc_test target
   src/dbus_client_iface.cpp
   src/item.cpp
 )
diff --git a/libs/ipc/inc/public/tfc/ipc/details/dbus_client_iface_mock.hpp b/libs/ipc/inc/public/tfc/ipc/details/dbus_client_iface_mock.hpp
index 0bea810736..3b23bc5fe3 100644
--- a/libs/ipc/inc/public/tfc/ipc/details/dbus_client_iface_mock.hpp
+++ b/libs/ipc/inc/public/tfc/ipc/details/dbus_client_iface_mock.hpp
@@ -23,8 +23,6 @@ namespace tfc::ipc_ruler {
 namespace asio = boost::asio;
 
 struct ipc_manager_client_mock {
-  ipc_manager_client_mock() = default;
-
   explicit ipc_manager_client_mock(asio::io_context&);
   explicit ipc_manager_client_mock(std::shared_ptr<sdbusplus::asio::connection>);
 
diff --git a/libs/ipc/src/dbus_server_iface_mock.cpp b/libs/ipc/src/dbus_client_iface_mock.cpp
similarity index 100%
rename from libs/ipc/src/dbus_server_iface_mock.cpp
rename to libs/ipc/src/dbus_client_iface_mock.cpp
diff --git a/libs/ipc/testing/tests/ipc_manager_test.cpp b/libs/ipc/testing/tests/ipc_manager_test.cpp
index c8ee7e8e6e..6a66c8b1ba 100644
--- a/libs/ipc/testing/tests/ipc_manager_test.cpp
+++ b/libs/ipc/testing/tests/ipc_manager_test.cpp
@@ -291,7 +291,7 @@ auto main(int argc, char** argv) -> int {
     uint8_t invocation{};
     bool ignore_first{ true };
 
-    tfc::ipc_ruler::ipc_manager_client_mock mock_client;
+    tfc::ipc_ruler::ipc_manager_client_mock mock_client{ isolated_ctx };
     const tfc::ipc::slot<tfc::ipc::details::type_bool, tfc::ipc_ruler::ipc_manager_client_mock&> slot(
         isolated_ctx, mock_client, "bool_slot", "", [&](bool value) {
           if (ignore_first) {
@@ -322,7 +322,7 @@ auto main(int argc, char** argv) -> int {
   "Test ipc communication connection and disconnection with mocking int"_test = []() {
     asio::io_context isolated_ctx{};
 
-    tfc::ipc_ruler::ipc_manager_client_mock mock_client;
+    tfc::ipc_ruler::ipc_manager_client_mock mock_client{ isolated_ctx };
 
     uint8_t invocation{};
     bool ignore_first{ true };
@@ -388,7 +388,7 @@ auto main(int argc, char** argv) -> int {
     test_class test_class_instance;
 
     asio::io_context isolated_ctx{};
-    tfc::ipc_ruler::ipc_manager_client_mock mock_client;
+    tfc::ipc_ruler::ipc_manager_client_mock mock_client{ isolated_ctx };
 
     mock_client.register_properties_change_callback(std::bind_front(&test_class::increment, &test_class_instance));
 

From bf5cc59e54a8c41deeffb1f6d6d5f06b0046c5d7 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=B3n=20Bjarni=20Bjarnason?= <jbbjarnason@gmail.com>
Date: Tue, 10 Oct 2023 09:49:50 +0000
Subject: [PATCH 28/33] naming

---
 libs/confman/src/detail/config_dbus_client.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/libs/confman/src/detail/config_dbus_client.cpp b/libs/confman/src/detail/config_dbus_client.cpp
index 35eac47f72..f0a7b0f541 100644
--- a/libs/confman/src/detail/config_dbus_client.cpp
+++ b/libs/confman/src/detail/config_dbus_client.cpp
@@ -50,14 +50,14 @@ config_dbus_client::config_dbus_client(asio::io_context& ctx,
   dbus_connection_->request_name(interface_name_.c_str());
 }
 
-config_dbus_client::config_dbus_client(interface_t intf,
+config_dbus_client::config_dbus_client(interface_t interface,
                                        std::string_view key,
                                        value_call_t&& value_call,
                                        schema_call_t&& schema_call,
                                        change_call_t&& change_call)
 
     : property_name_{ key }, value_call_{ std::move(value_call) }, schema_call_{ std::move(schema_call) },
-      change_call_{ std::move(change_call) }, dbus_interface_{ std::move(intf) } {}
+      change_call_{ std::move(change_call) }, dbus_interface_{ std::move(interface) } {}
 
 void config_dbus_client::set(config_property&& prop) const {
   if (dbus_interface_) {

From 7a67cac186a105ef76a0c5e662055d79ef61bb83 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=B3n=20Bjarni=20Bjarnason?= <jbbjarnason@gmail.com>
Date: Tue, 10 Oct 2023 11:16:06 +0000
Subject: [PATCH 29/33] fix operation mode after service name changes

---
 .../inc/details/app_operation_mode_impl.hpp           |  7 ++++++-
 .../tests/operation_mode_integration_test.cpp         |  2 +-
 libs/operation_mode/inc/public/tfc/operation_mode.hpp |  8 +++++++-
 .../inc/public/tfc/operation_mode/common.hpp          |  9 ++++++---
 libs/operation_mode/src/operation_mode.cpp            | 11 ++++++-----
 5 files changed, 26 insertions(+), 11 deletions(-)

diff --git a/exes/operations/inc/details/app_operation_mode_impl.hpp b/exes/operations/inc/details/app_operation_mode_impl.hpp
index a9f7095f1b..eb65eefb5a 100644
--- a/exes/operations/inc/details/app_operation_mode_impl.hpp
+++ b/exes/operations/inc/details/app_operation_mode_impl.hpp
@@ -39,7 +39,12 @@ app_operation_mode<signal_t, slot_t>::app_operation_mode(boost::asio::io_context
     message.signal_send();
   });
 
-  dbus_->request_name(tfc::dbus::make_dbus_process_name().c_str());
+  auto service_name{ tfc::dbus::make_dbus_process_name() };
+  if (service_name != tfc::operation::dbus::service_name) {
+    logger_.info("Service name '{}' is not default '{}'", service_name, tfc::operation::dbus::service_default);
+  }
+
+  dbus_->request_name(service_name.c_str());
 
   dbus_interface_->initialize();
 
diff --git a/exes/operations/tests/operation_mode_integration_test.cpp b/exes/operations/tests/operation_mode_integration_test.cpp
index ef153a2b8e..3630bf28c7 100644
--- a/exes/operations/tests/operation_mode_integration_test.cpp
+++ b/exes/operations/tests/operation_mode_integration_test.cpp
@@ -21,7 +21,7 @@ struct operation_mode_test {
   asio::io_context ctx{};
   tfc::app_operation_mode<tfc::ipc::mock_signal, tfc::ipc::mock_slot> app{ ctx };
   tfc::operation::interface lib {
-    ctx
+    ctx, "operation", tfc::dbus::make_dbus_process_name()
   };
   ~operation_mode_test() {
     std::error_code code;
diff --git a/libs/operation_mode/inc/public/tfc/operation_mode.hpp b/libs/operation_mode/inc/public/tfc/operation_mode.hpp
index dbb06d3258..1c66619add 100644
--- a/libs/operation_mode/inc/public/tfc/operation_mode.hpp
+++ b/libs/operation_mode/inc/public/tfc/operation_mode.hpp
@@ -28,7 +28,12 @@ concept transition_callback = std::invocable<callback_t, new_mode_e, old_mode_e>
 class interface {
 public:
   explicit interface(boost::asio::io_context& ctx) : interface(ctx, "operation") {}
-  interface(boost::asio::io_context& ctx, std::string_view log_key);
+  interface(boost::asio::io_context& ctx, std::string_view log_key) : interface(ctx, log_key, dbus::service_default) {}
+  /// \brief construct an interface to operation mode controller
+  /// \param ctx context to run in
+  /// \param log_key key to use for logging
+  /// \param dbus_service_name name of the service to connect to
+  interface(boost::asio::io_context& ctx, std::string_view log_key, std::string_view dbus_service_name);
   interface(interface const&) = delete;
   auto operator=(interface const&) -> interface& = delete;
   interface(interface&&) noexcept;
@@ -127,6 +132,7 @@ class interface {
 
   mode_e current_mode_{ mode_e::unknown };
   uuid_t next_uuid_{};
+  std::string dbus_service_name_{};
   std::vector<callback_item> callbacks_{};
   std::unique_ptr<sdbusplus::asio::connection, std::function<void(sdbusplus::asio::connection*)>> dbus_connection_{};
   std::unique_ptr<sdbusplus::bus::match::match, std::function<void(sdbusplus::bus::match::match*)>> mode_updates_{};
diff --git a/libs/operation_mode/inc/public/tfc/operation_mode/common.hpp b/libs/operation_mode/inc/public/tfc/operation_mode/common.hpp
index 6e7be7c0ef..99d11ccd46 100644
--- a/libs/operation_mode/inc/public/tfc/operation_mode/common.hpp
+++ b/libs/operation_mode/inc/public/tfc/operation_mode/common.hpp
@@ -27,9 +27,12 @@ enum struct mode_e : std::uint8_t {
 [[nodiscard]] auto enum_cast(std::string_view enum_name) -> std::optional<mode_e>;
 
 namespace dbus {
-static constexpr std::string_view service_name{ "OperationMode" };
-static constexpr std::string_view name{ tfc::dbus::const_dbus_name<service_name> };
-static constexpr std::string_view path{ tfc::dbus::const_dbus_path<service_name> };
+// Please note that this needs to match the generated service name of the operation mode daemon
+static constexpr std::string_view service_default{ "tfc.Operations.def" };
+static constexpr std::string_view service_name{ tfc::dbus::const_dbus_name<service_default> };
+static constexpr std::string_view interface_name{ "OperationMode" };
+static constexpr std::string_view name{ tfc::dbus::const_dbus_name<interface_name> };
+static constexpr std::string_view path{ tfc::dbus::const_dbus_path<interface_name> };
 namespace method {
 static constexpr std::string_view set_mode{ "SetMode" };
 }
diff --git a/libs/operation_mode/src/operation_mode.cpp b/libs/operation_mode/src/operation_mode.cpp
index 9a0a2af36a..550d871b58 100644
--- a/libs/operation_mode/src/operation_mode.cpp
+++ b/libs/operation_mode/src/operation_mode.cpp
@@ -36,13 +36,14 @@ MESSAGE "(ss)" {
                           tfc::dbus::match::rules::path<tfc::operation::dbus::path>>
 };
 
-interface::interface(asio::io_context& ctx, std::string_view log_key)
-    : dbus_connection_{ std::make_unique<sdbusplus::asio::connection>(ctx, tfc::dbus::sd_bus_open_system()) },
+interface::interface(asio::io_context& ctx, std::string_view log_key, std::string_view dbus_service_name)
+    : dbus_service_name_{ dbus_service_name },
+      dbus_connection_{ std::make_unique<sdbusplus::asio::connection>(ctx, tfc::dbus::sd_bus_open_system()) },
       mode_updates_{ std::make_unique<sdbusplus::bus::match_t>(*dbus_connection_,
                                                                mode_update_match_rule.data(),
                                                                std::bind_front(&interface::mode_update, this)) },
       logger_{ log_key } {
-  sdbusplus::asio::getProperty<mode_e>(*dbus_connection_, std::string{ dbus::name }, std::string{ dbus::path },
+  sdbusplus::asio::getProperty<mode_e>(*dbus_connection_, dbus_service_name_, std::string{ dbus::path },
                                        std::string{ dbus::name }, std::string{ dbus::property::mode },
                                        [this](auto err, mode_e const& mode) {
                                          if (err) {
@@ -77,8 +78,8 @@ auto interface::operator=(interface&& to_be_erased) noexcept -> interface& {
 void interface::set(tfc::operation::mode_e new_mode) const {
   // todo add handler to set function call, for callee
   dbus_connection_->async_method_call(
-      [this](std::error_code err) { logger_.warn("Error from set mode: {}", err.message()); }, dbus::name.data(),
-      dbus::path.data(), dbus::name.data(), dbus::method::set_mode.data(), new_mode);
+      [this](std::error_code err) { logger_.warn("Error from set mode: {}", err.message()); }, dbus_service_name_,
+      std::string{ dbus::path }, std::string{ dbus::name }, std::string{ dbus::method::set_mode }, new_mode);
 }
 
 void interface::mode_update(sdbusplus::message::message& msg) noexcept {

From d69ef4fe3549099ea01d65908d005b26830d6f2d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=B3n=20Bjarni=20Bjarnason?= <jbbjarnason@gmail.com>
Date: Tue, 10 Oct 2023 12:36:20 +0000
Subject: [PATCH 30/33] fix segfault in test

---
 exes/operations/tests/operations_state_machine_owner_test.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/exes/operations/tests/operations_state_machine_owner_test.cpp b/exes/operations/tests/operations_state_machine_owner_test.cpp
index dcbae9bbe2..d54939813a 100644
--- a/exes/operations/tests/operations_state_machine_owner_test.cpp
+++ b/exes/operations/tests/operations_state_machine_owner_test.cpp
@@ -68,7 +68,7 @@ struct state_machine_mock {
 
 struct test_instance {
   asio::io_context ctx{};
-  std::shared_ptr<sdbusplus::asio::connection> dbus{};
+  std::shared_ptr<sdbusplus::asio::connection> dbus{ std::make_shared<sdbusplus::asio::connection>(ctx) };
   tfc::operation::state_machine_owner<tfc::ipc::mock_signal, tfc::ipc::mock_slot, state_machine_mock> owner{ ctx, dbus };
 };
 

From 689ef6b4810117d27a79df2f672729df12ecb677 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=B3n=20Bjarni=20Bjarnason?= <jbbjarnason@gmail.com>
Date: Tue, 10 Oct 2023 12:55:04 +0000
Subject: [PATCH 31/33] fix confman tests

---
 .../inc/public/tfc/confman/detail/config_dbus_client.hpp     | 2 ++
 libs/confman/src/detail/config_dbus_client.cpp               | 4 ----
 libs/confman/testing/tests/confman_test.cpp                  | 5 ++---
 3 files changed, 4 insertions(+), 7 deletions(-)

diff --git a/libs/confman/inc/public/tfc/confman/detail/config_dbus_client.hpp b/libs/confman/inc/public/tfc/confman/detail/config_dbus_client.hpp
index 54634b50ff..4c7f0a5b7b 100644
--- a/libs/confman/inc/public/tfc/confman/detail/config_dbus_client.hpp
+++ b/libs/confman/inc/public/tfc/confman/detail/config_dbus_client.hpp
@@ -7,6 +7,7 @@
 #include <system_error>
 
 #include <tfc/dbus/sdbusplus_fwd.hpp>
+#include <tfc/dbus/string_maker.hpp>
 #include <tfc/stx/to_tuple.hpp>
 
 namespace boost::asio {
@@ -33,6 +34,7 @@ struct config_property {
 namespace dbus {
 static constexpr std::string_view property_name{ "config" };
 static constexpr std::string_view config_path{ "Config" };
+static constexpr std::string_view path{ tfc::dbus::const_dbus_path<config_path> };
 }  // namespace dbus
 
 class config_dbus_client {
diff --git a/libs/confman/src/detail/config_dbus_client.cpp b/libs/confman/src/detail/config_dbus_client.cpp
index f0a7b0f541..941012bd28 100644
--- a/libs/confman/src/detail/config_dbus_client.cpp
+++ b/libs/confman/src/detail/config_dbus_client.cpp
@@ -4,7 +4,6 @@
 #include <tfc/dbus/exception.hpp>
 #include <tfc/dbus/sd_bus.hpp>
 #include <tfc/dbus/sdbusplus_meta.hpp>
-#include <tfc/dbus/string_maker.hpp>
 #include <tfc/progbase.hpp>
 
 #include <fmt/format.h>
@@ -20,9 +19,6 @@ namespace tfc::confman::detail {
 // busctl --system introspect com.skaginn3x.config.operation_mode.def.state_machine /com/skaginn3x/etc/tfc/config
 // clang-format on
 
-namespace dbus {
-static constexpr std::string_view path{ tfc::dbus::const_dbus_path<config_path> };
-}
 
 config_dbus_client::config_dbus_client(boost::asio::io_context&) {}
 
diff --git a/libs/confman/testing/tests/confman_test.cpp b/libs/confman/testing/tests/confman_test.cpp
index b2abd514d7..00fcd719b1 100644
--- a/libs/confman/testing/tests/confman_test.cpp
+++ b/libs/confman/testing/tests/confman_test.cpp
@@ -53,8 +53,7 @@ auto main(int argc, char** argv) -> int {
   std::string const key{ "bar" };
 
   // duplicate from config_dbus_client.cpp
-  std::filesystem::path interface_path{ tfc::dbus::make_dbus_path(
-      fmt::format("{}config", tfc::base::get_config_directory().string().substr(1))) };
+  std::filesystem::path interface_path{ tfc::confman::detail::dbus::path };
   auto interface_name{ tfc::dbus::make_dbus_name(
       fmt::format("config.{}.{}.{}", tfc::base::get_exe_name(), tfc::base::get_proc_name(), key)) };
 
@@ -173,7 +172,7 @@ auto main(int argc, char** argv) -> int {
 
     uint32_t called{};
     sdbusplus::asio::setProperty<config_property>(dbus, interface_name, interface_path.string(), interface_name,
-                                                  std::string{ property_name.data(), property_name.size() },
+                                                  std::string{ property_name },
                                                   config_property{ R"({"a":11,"b":12,"c":"a"})", "" },
                                                   [&called, &conf]([[maybe_unused]] std::error_code err) {
                                                     if (err) {

From e2cef61d5266e1d843675b115990da13787ccb8b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=B3n=20Bjarni=20Bjarnason?= <jbbjarnason@gmail.com>
Date: Tue, 10 Oct 2023 13:32:43 +0000
Subject: [PATCH 32/33] damn boy fix ipc

---
 libs/ipc/inc/public/tfc/ipc/details/impl.hpp | 2 --
 1 file changed, 2 deletions(-)

diff --git a/libs/ipc/inc/public/tfc/ipc/details/impl.hpp b/libs/ipc/inc/public/tfc/ipc/details/impl.hpp
index 4e3159d7ba..661d9a8f56 100644
--- a/libs/ipc/inc/public/tfc/ipc/details/impl.hpp
+++ b/libs/ipc/inc/public/tfc/ipc/details/impl.hpp
@@ -330,9 +330,7 @@ class slot_callback : public std::enable_shared_from_this<slot_callback<type_des
       // clang-format on
       last_value_ = std::move(new_value.value());
       callback(last_value_.value());
-      return;
     }
-
     register_read(std::forward<decltype(callback)>(callback));
   }
   void register_read(tfc::stx::invocable<value_t> auto&& callback) {

From f0f76eb792cea634c433430eeb910f6707903818 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=B3n=20Bjarni=20Bjarnason?= <jbbjarnason@gmail.com>
Date: Tue, 10 Oct 2023 13:32:22 +0000
Subject: [PATCH 33/33] Committing clang-format changes

---
 .../confman/src/detail/config_dbus_client.cpp |  1 -
 libs/confman/testing/tests/confman_test.cpp   | 23 +++++++++----------
 2 files changed, 11 insertions(+), 13 deletions(-)

diff --git a/libs/confman/src/detail/config_dbus_client.cpp b/libs/confman/src/detail/config_dbus_client.cpp
index 941012bd28..4e094ec5db 100644
--- a/libs/confman/src/detail/config_dbus_client.cpp
+++ b/libs/confman/src/detail/config_dbus_client.cpp
@@ -19,7 +19,6 @@ namespace tfc::confman::detail {
 // busctl --system introspect com.skaginn3x.config.operation_mode.def.state_machine /com/skaginn3x/etc/tfc/config
 // clang-format on
 
-
 config_dbus_client::config_dbus_client(boost::asio::io_context&) {}
 
 config_dbus_client::config_dbus_client(dbus_connection_t conn,
diff --git a/libs/confman/testing/tests/confman_test.cpp b/libs/confman/testing/tests/confman_test.cpp
index 00fcd719b1..ffb02858a3 100644
--- a/libs/confman/testing/tests/confman_test.cpp
+++ b/libs/confman/testing/tests/confman_test.cpp
@@ -171,18 +171,17 @@ auto main(int argc, char** argv) -> int {
     });
 
     uint32_t called{};
-    sdbusplus::asio::setProperty<config_property>(dbus, interface_name, interface_path.string(), interface_name,
-                                                  std::string{ property_name },
-                                                  config_property{ R"({"a":11,"b":12,"c":"a"})", "" },
-                                                  [&called, &conf]([[maybe_unused]] std::error_code err) {
-                                                    if (err) {
-                                                      fmt::print(stderr, "Set property error: '{}'", err.message());
-                                                    }
-                                                    called++;
-                                                    ut::expect(conf->a == 11);
-                                                    ut::expect(conf->b == 12);
-                                                    ut::expect(conf->c == "a");
-                                                  });
+    sdbusplus::asio::setProperty<config_property>(
+        dbus, interface_name, interface_path.string(), interface_name, std::string{ property_name },
+        config_property{ R"({"a":11,"b":12,"c":"a"})", "" }, [&called, &conf]([[maybe_unused]] std::error_code err) {
+          if (err) {
+            fmt::print(stderr, "Set property error: '{}'", err.message());
+          }
+          called++;
+          ut::expect(conf->a == 11);
+          ut::expect(conf->b == 12);
+          ut::expect(conf->c == "a");
+        });
 
     ctx.run_for(std::chrono::milliseconds(10));
     ut::expect(called == 1);