From e0739d4922d1a555a7ac07c5b09e80f7287cf2d0 Mon Sep 17 00:00:00 2001
From: yousongyang <yousongyang0105@gmail.com>
Date: Tue, 9 Jun 2026 11:20:27 +0800
Subject: [PATCH 01/12] =?UTF-8?q?ETCD=20=E4=B8=8E=20Discovery=20=E5=88=86?=
 =?UTF-8?q?=E7=A6=BB?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 include/atframe/atapp.h                       |   16 +-
 include/atframe/etcdcli/etcd_discovery.h      |    7 +-
 include/atframe/modules/etcd_module.h         |  272 +--
 .../modules/service_discovery_module.h        |  309 ++++
 src/CMakeLists.txt                            |    2 +
 src/atframe/atapp.cpp                         |  215 ++-
 .../connectors/atapp_connector_atbus.cpp      |    6 +-
 src/atframe/etcdcli/etcd_discovery.cpp        |    9 +-
 src/atframe/modules/etcd_module.cpp           | 1601 ++---------------
 .../modules/service_discovery_module.cpp      | 1556 ++++++++++++++++
 test/case/atapp_direct_connect_test.cpp       |   31 +-
 test/case/atapp_discovery_reconnect_test.cpp  |   17 +-
 test/case/atapp_discovery_test.cpp            |   24 +-
 test/case/atapp_downstream_send_test.cpp      |   29 +-
 test/case/atapp_error_recovery_test.cpp       |   17 +-
 test/case/atapp_etcd_cluster_test.cpp         |  145 +-
 test/case/atapp_etcd_module_test.cpp          |  545 +++---
 test/case/atapp_etcd_module_unit_test.cpp     |   49 +-
 test/case/atapp_message_test.cpp              |   15 +-
 test/case/atapp_topology_change_test.cpp      |   57 +-
 test/case/atapp_upstream_forward_test.cpp     |   59 +-
 21 files changed, 2633 insertions(+), 2348 deletions(-)
 create mode 100644 include/atframe/modules/service_discovery_module.h
 create mode 100644 src/atframe/modules/service_discovery_module.cpp

diff --git a/include/atframe/atapp.h b/include/atframe/atapp.h
index d4d31f5..e128876 100644
--- a/include/atframe/atapp.h
+++ b/include/atframe/atapp.h
@@ -50,9 +50,11 @@ ATBUS_MACRO_NAMESPACE_END
 LIBATAPP_MACRO_NAMESPACE_BEGIN
 
 class etcd_module;
+class service_discovery_module;
 class worker_pool_module;
 class atapp_connector_atbus;
 class atapp_connector_loopback;
+struct curl_multi_guard_type;
 
 class app {
  public:
@@ -394,7 +396,8 @@ class app {
 
   LIBATAPP_MACRO_API void pack(atapp::protocol::atapp_discovery &out) const;
 
-  LIBATAPP_MACRO_API const std::shared_ptr<::atframework::atapp::etcd_module> &get_etcd_module() const noexcept;
+  LIBATAPP_MACRO_API const std::shared_ptr<::atframework::atapp::service_discovery_module> &
+  get_service_discovery_module() const noexcept;
 
   LIBATAPP_MACRO_API const std::shared_ptr<::atframework::atapp::worker_pool_module> &get_worker_pool_module()
       const noexcept;
@@ -601,6 +604,8 @@ class app {
 
   int setup_atbus();
 
+  int setup_curl_multi();
+
   static void close_timer(timer_ptr_t &t);
 
   int setup_tick_timer();
@@ -663,8 +668,8 @@ class app {
   int command_handler_stop(atfw::util::cli::callback_param params);
   int command_handler_reload(atfw::util::cli::callback_param params);
   int command_handler_invalid(atfw::util::cli::callback_param params);
-  int command_handler_disable_etcd(atfw::util::cli::callback_param params);
-  int command_handler_enable_etcd(atfw::util::cli::callback_param params);
+  int command_handler_disable_discovery(atfw::util::cli::callback_param params);
+  int command_handler_enable_discovery(atfw::util::cli::callback_param params);
   int command_handler_list_discovery(atfw::util::cli::callback_param params);
 
  private:
@@ -786,9 +791,12 @@ class app {
   };
   stats_data_t stats_;
 
+  std::shared_ptr<curl_multi_guard_type> curl_multi_guard_;
+  atfw::util::network::http_request::curl_m_bind_ptr_t curl_multi_;
+
   // inner modules
   std::shared_ptr<::atframework::atapp::worker_pool_module> internal_module_worker_pool_;
-  std::shared_ptr<::atframework::atapp::etcd_module> internal_module_etcd_;
+  std::shared_ptr<::atframework::atapp::service_discovery_module> internal_module_service_discovery_;
   etcd_discovery_set internal_empty_discovery_set_;
 
   // inner endpoints
diff --git a/include/atframe/etcdcli/etcd_discovery.h b/include/atframe/etcdcli/etcd_discovery.h
index a633867..f98f8e7 100644
--- a/include/atframe/etcdcli/etcd_discovery.h
+++ b/include/atframe/etcdcli/etcd_discovery.h
@@ -49,10 +49,12 @@ class etcd_discovery_node {
   ATFW_UTIL_FORCEINLINE const atapp::protocol::atapp_discovery &get_discovery_info() const { return node_info_; }
   ATFW_UTIL_FORCEINLINE const node_version &get_version() const noexcept { return node_version_; }
 
-  LIBATAPP_MACRO_API void copy_from(const atapp::protocol::atapp_discovery &input, const node_version &version);
-  LIBATAPP_MACRO_API void update_version(const node_version &version, bool upgrade);
+  LIBATAPP_MACRO_API void copy_from(const atapp::protocol::atapp_discovery &input, const node_version &version,
+                                    uintptr_t context_ptr);
+  LIBATAPP_MACRO_API void update_version(const node_version &version, bool upgrade, uintptr_t context_ptr);
   LIBATAPP_MACRO_API void copy_to(atapp::protocol::atapp_discovery &output) const;
   LIBATAPP_MACRO_API void copy_key_to(atapp::protocol::atapp_discovery &output) const;
+  LIBATAPP_MACRO_API uintptr_t get_context_ptr() const noexcept { return context_ptr_; }
 
   ATFW_UTIL_FORCEINLINE const std::pair<uint64_t, uint64_t> &get_name_hash() const noexcept { return name_hash_; }
 
@@ -78,6 +80,7 @@ class etcd_discovery_node {
  private:
   atapp::protocol::atapp_discovery node_info_;
   node_version node_version_;
+  uintptr_t context_ptr_;
 
   std::pair<uint64_t, uint64_t> name_hash_;
   union {
diff --git a/include/atframe/modules/etcd_module.h b/include/atframe/modules/etcd_module.h
index 9cfcf15..30fbdd9 100644
--- a/include/atframe/modules/etcd_module.h
+++ b/include/atframe/modules/etcd_module.h
@@ -6,293 +6,65 @@
 
 #include <config/atframe_utils_build_feature.h>
 
-#include <config/compiler/template_prefix.h>
-
-#include <rapidjson/document.h>
-
-#include <config/compiler/template_suffix.h>
-
 #include <atframe/atapp_conf.h>
 
 #include <network/http_request.h>
-#include <random/random_generator.h>
 #include <time/time_utility.h>
 
-#include <atframe/atapp_module_impl.h>
-
 #include <atframe/etcdcli/etcd_cluster.h>
 #include <atframe/etcdcli/etcd_discovery.h>
 #include <atframe/etcdcli/etcd_keepalive.h>
 #include <atframe/etcdcli/etcd_watcher.h>
 
 #include <list>
-#include <mutex>
-#include <set>
 #include <string>
-#include <unordered_map>
 
 LIBATAPP_MACRO_NAMESPACE_BEGIN
-class etcd_module : public ::atframework::atapp::module_impl {
- public:
-  // ============ 服务发现数据和事件相关定义 ============
-  using node_action_t = etcd_discovery_action_t;
-
-  struct LIBATAPP_MACRO_API_HEAD_ONLY node_info_t {
-    atapp::protocol::atapp_discovery node_discovery;
-    node_action_t action;
-  };
-
-  struct LIBATAPP_MACRO_API_HEAD_ONLY node_list_t {
-    std::list<node_info_t> nodes;
-  };
-
-  struct LIBATAPP_MACRO_API_HEAD_ONLY discovery_watcher_sender_list_t {
-    std::reference_wrapper<etcd_module> atapp_module;
-    std::reference_wrapper<const ::atframework::atapp::etcd_response_header> etcd_header;
-    std::reference_wrapper<const ::atframework::atapp::etcd_watcher::response_t> etcd_body;
-    std::reference_wrapper<const ::atframework::atapp::etcd_watcher::event_t> event;
-    std::reference_wrapper<const node_info_t> node;
-
-    inline discovery_watcher_sender_list_t(etcd_module &m, const ::atframework::atapp::etcd_response_header &h,
-                                           const ::atframework::atapp::etcd_watcher::response_t &b,
-                                           const ::atframework::atapp::etcd_watcher::event_t &e, const node_info_t &n)
-        : atapp_module(std::ref(m)),
-          etcd_header(std::cref(h)),
-          etcd_body(std::cref(b)),
-          event(std::cref(e)),
-          node(std::cref(n)) {}
-  };
-
-  using discovery_watcher_list_callback_t = std::function<void(discovery_watcher_sender_list_t &)>;
-
-  using discovery_snapshot_event_callback_t = std::function<void(const etcd_module &)>;
-  using discovery_snapshot_event_callback_list_t = std::list<discovery_snapshot_event_callback_t>;
-  using discovery_snapshot_event_callback_handle_t = discovery_snapshot_event_callback_list_t::iterator;
-
-  using node_event_callback_t = std::function<void(node_action_t, const etcd_discovery_node::ptr_t &)>;
-  using node_event_callback_list_t = std::list<node_event_callback_t>;
-  using node_event_callback_handle_t = node_event_callback_list_t::iterator;
-
-  // ============ 拓扑数据和事件相关定义 ============
-  using topology_action_t = etcd_watch_event;
-  using atapp_topology_info_ptr_t = atfw::util::memory::strong_rc_ptr<atapp::protocol::atapp_topology_info>;
-
-  struct LIBATAPP_MACRO_API_HEAD_ONLY topology_storage_t {
-    atapp_topology_info_ptr_t info;
-    etcd_data_version version;
-  };
-
-  struct LIBATAPP_MACRO_API_HEAD_ONLY topology_info_t {
-    topology_storage_t storage;
-    topology_action_t action;
-  };
-
-  struct LIBATAPP_MACRO_API_HEAD_ONLY topology_list_t {
-    std::list<topology_info_t> topologies;
-  };
 
-  struct LIBATAPP_MACRO_API_HEAD_ONLY topology_watcher_sender_list_t {
-    std::reference_wrapper<etcd_module> atapp_module;
-    std::reference_wrapper<const ::atframework::atapp::etcd_response_header> etcd_header;
-    std::reference_wrapper<const ::atframework::atapp::etcd_watcher::response_t> etcd_body;
-    std::reference_wrapper<const ::atframework::atapp::etcd_watcher::event_t> event;
-    std::reference_wrapper<const topology_info_t> topology;
-
-    inline topology_watcher_sender_list_t(etcd_module &m, const ::atframework::atapp::etcd_response_header &h,
-                                          const ::atframework::atapp::etcd_watcher::response_t &b,
-                                          const ::atframework::atapp::etcd_watcher::event_t &e,
-                                          const topology_info_t &n)
-        : atapp_module(std::ref(m)),
-          etcd_header(std::cref(h)),
-          etcd_body(std::cref(b)),
-          event(std::cref(e)),
-          topology(std::cref(n)) {}
-  };
-
-  using topology_watcher_list_callback_t = std::function<void(topology_watcher_sender_list_t &)>;
-
-  using topology_snapshot_event_callback_t = std::function<void(const etcd_module &)>;
-  using topology_snapshot_event_callback_list_t = std::list<topology_snapshot_event_callback_t>;
-  using topology_snapshot_event_callback_handle_t = topology_snapshot_event_callback_list_t::iterator;
-
-  using topology_info_event_callback_t =
-      std::function<void(topology_action_t, const atapp_topology_info_ptr_t &, const etcd_data_version &)>;
-  using topology_info_event_callback_list_t = std::list<topology_info_event_callback_t>;
-  using topology_info_event_callback_handle_t = topology_info_event_callback_list_t::iterator;
+class app;
 
+class etcd_module {
  public:
   LIBATAPP_MACRO_API etcd_module();
   LIBATAPP_MACRO_API virtual ~etcd_module();
 
  public:
+  LIBATAPP_MACRO_API int init(atframework::atapp::app &app, const atapp::protocol::atapp_etcd &conf,
+                              const atapp::protocol::atapp_log *ATFW_UTIL_MACRO_NULLABLE log_conf);
+  LIBATAPP_MACRO_API int reload(const atapp::protocol::atapp_etcd &conf,
+                                const atapp::protocol::atapp_log *ATFW_UTIL_MACRO_NULLABLE log_conf);
+  LIBATAPP_MACRO_API int stop();
   LIBATAPP_MACRO_API void reset();
-
-  LIBATAPP_MACRO_API int init() override;
-
- private:
-  void update_keepalive_topology_value();
-  void update_keepalive_discovery_value();
-  int init_keepalives();
-  int init_watchers();
+  LIBATAPP_MACRO_API int tick();
 
  public:
-  LIBATAPP_MACRO_API int reload() override;
-
-  LIBATAPP_MACRO_API int stop() override;
-
-  LIBATAPP_MACRO_API int timeout() override;
-
-  LIBATAPP_MACRO_API const char *ATFW_UTIL_MACRO_NONNULL name() const override;
-
-  LIBATAPP_MACRO_API int tick() override;
-
-  LIBATAPP_MACRO_API const std::string &get_conf_custom_data() const;
-  LIBATAPP_MACRO_API void set_conf_custom_data(const std::string &v);
-
-  LIBATAPP_MACRO_API bool is_etcd_enabled() const;
-  LIBATAPP_MACRO_API void enable_etcd();
-  LIBATAPP_MACRO_API void disable_etcd();
-  LIBATAPP_MACRO_API void set_maybe_update_keepalive_topology_value();
-  LIBATAPP_MACRO_API void set_maybe_update_keepalive_discovery_value();
-  LIBATAPP_MACRO_API void set_maybe_update_keepalive_discovery_area();
-  LIBATAPP_MACRO_API void set_maybe_update_keepalive_discovery_metadata();
+  LIBATAPP_MACRO_API atapp::etcd_cluster &get_etcd_cluster();
+  LIBATAPP_MACRO_API const atapp::etcd_cluster &get_etcd_cluster() const;
+  LIBATAPP_MACRO_API const std::string &get_configure_path();
+  LIBATAPP_MACRO_API const atapp::protocol::atapp_etcd &get_configure() const;
 
-  LIBATAPP_MACRO_API static bool check_keepalive_actor_start_success(
-      atframework::atapp::app *ATFW_UTIL_MACRO_NONNULL app,
+  LIBATAPP_MACRO_API bool check_keepalive_actor_start_success(
       gsl::span<const std::list<etcd_keepalive::ptr_t> *> keepalive_actors);
 
-  LIBATAPP_MACRO_API const atfw::util::network::http_request::curl_m_bind_ptr_t &get_shared_curl_multi_context() const;
-
-  LIBATAPP_MACRO_API std::string get_discovery_by_id_path() const;
-  LIBATAPP_MACRO_API std::string get_discovery_by_name_path() const;
-  LIBATAPP_MACRO_API std::string get_topology_path() const;
-
-  LIBATAPP_MACRO_API std::string get_discovery_by_id_watcher_path() const;
-  LIBATAPP_MACRO_API std::string get_discovery_by_name_watcher_path() const;
-  LIBATAPP_MACRO_API std::string get_topology_watcher_path() const;
-
-  LIBATAPP_MACRO_API int add_discovery_watcher_by_id(const discovery_watcher_list_callback_t &fn);
-  LIBATAPP_MACRO_API int add_discovery_watcher_by_name(const discovery_watcher_list_callback_t &fn);
-  LIBATAPP_MACRO_API int add_topology_watcher(const topology_watcher_list_callback_t &fn);
-
-  LIBATAPP_MACRO_API const ::atframework::atapp::etcd_cluster &get_raw_etcd_ctx() const;
-  LIBATAPP_MACRO_API ::atframework::atapp::etcd_cluster &get_raw_etcd_ctx();
-
-  LIBATAPP_MACRO_API const ::atframework::atapp::etcd_response_header &get_last_etcd_event_topology_header()
-      const noexcept;
-  LIBATAPP_MACRO_API const ::atframework::atapp::etcd_response_header &get_last_etcd_event_discovery_header()
-      const noexcept;
-
-  LIBATAPP_MACRO_API const atapp::protocol::atapp_etcd &get_configure() const;
-  LIBATAPP_MACRO_API const std::string &get_configure_path() const;
   LIBATAPP_MACRO_API static std::string generate_etcd_path(const std::string &path);
 
-  LIBATAPP_MACRO_API atapp::etcd_keepalive::ptr_t add_keepalive_actor(std::string &val, const std::string &node_path);
-
-  LIBATAPP_MACRO_API bool remove_keepalive_actor(const atapp::etcd_keepalive::ptr_t &keepalive);
-
-  LIBATAPP_MACRO_API node_event_callback_handle_t add_on_node_discovery_event(const node_event_callback_t &fn);
-  LIBATAPP_MACRO_API void remove_on_node_event(node_event_callback_handle_t &handle);
-
-  LIBATAPP_MACRO_API topology_info_event_callback_handle_t
-  add_on_topology_info_event(const topology_info_event_callback_t &fn);
-  LIBATAPP_MACRO_API void remove_on_topology_info_event(topology_info_event_callback_handle_t &handle);
-
-  LIBATAPP_MACRO_API etcd_discovery_set &get_global_discovery() noexcept;
-  LIBATAPP_MACRO_API const etcd_discovery_set &get_global_discovery() const noexcept;
-
-  LIBATAPP_MACRO_API const std::unordered_map<uint64_t, topology_storage_t> &get_topology_info_set() const noexcept;
-
-  LIBATAPP_MACRO_API bool has_discovery_snapshot() const noexcept;
-
-  LIBATAPP_MACRO_API discovery_snapshot_event_callback_handle_t
-  add_on_load_discovery_snapshot(const discovery_snapshot_event_callback_t &fn);
-  LIBATAPP_MACRO_API void remove_on_load_discovery_snapshot(discovery_snapshot_event_callback_handle_t &handle);
-  LIBATAPP_MACRO_API discovery_snapshot_event_callback_handle_t
-  add_on_discovery_snapshot_loaded(const discovery_snapshot_event_callback_t &fn);
-  LIBATAPP_MACRO_API void remove_on_discovery_snapshot_loaded(discovery_snapshot_event_callback_handle_t &handle);
-
-  LIBATAPP_MACRO_API bool has_topology_snapshot() const noexcept;
-
-  LIBATAPP_MACRO_API topology_snapshot_event_callback_handle_t
-  add_on_load_topology_snapshot(const topology_snapshot_event_callback_t &fn);
-  LIBATAPP_MACRO_API void remove_on_load_topology_snapshot(topology_snapshot_event_callback_handle_t &handle);
-  LIBATAPP_MACRO_API topology_snapshot_event_callback_handle_t
-  add_on_topology_snapshot_loaded(const topology_snapshot_event_callback_t &fn);
-  LIBATAPP_MACRO_API void remove_on_topology_snapshot_loaded(topology_snapshot_event_callback_handle_t &handle);
-
-  LIBATAPP_MACRO_API etcd_watcher::watch_event_fn_t_ptr create_discovery_watcher_callback_list_wrapper();
-  LIBATAPP_MACRO_API etcd_watcher::watch_event_fn_t_ptr create_topology_watcher_callback_list_wrapper();
+  LIBATAPP_MACRO_API bool is_etcd_enabled() const;
 
  private:
-  static bool unpack(node_info_t &out, const std::string &path, const std::string &json, bool reset_data);
-  static void pack(const node_info_t &src, std::string &json);
-  static bool unpack(topology_info_t &out, const std::string &path, const std::string &json, bool reset_data);
-  static void pack(const atapp::protocol::atapp_topology_info &src, std::string &json);
-
   static int http_callback_on_etcd_closed(atfw::util::network::http_request &req);
+  void load_cluster_conf(const atapp::protocol::atapp_etcd &conf,
+                         const atapp::protocol::atapp_log *ATFW_UTIL_MACRO_NULLABLE log_conf = nullptr);
 
-  struct topology_watcher_callback_list_wrapper_t;
-  struct discovery_watcher_callback_list_wrapper_t;
-
-  bool update_internal_watcher_event(node_info_t &node, const etcd_discovery_node::node_version &version);
-  bool update_internal_watcher_event(topology_info_t &topology_info);
-  void reset_internal_watchers_and_keepalives();
+  bool enable_;
+  atfw::util::network::http_request::ptr_t cleanup_request_;
 
-  struct watcher_internal_access_t;
+  atframework::atapp::app *ATFW_UTIL_MACRO_NULLABLE atapp_;
+  atapp::etcd_cluster cluster_;
 
- private:
+  // Config
   std::string conf_path_cache_;
-  std::string custom_data_;
-  atfw::util::network::http_request::curl_m_bind_ptr_t curl_multi_;
-  atfw::util::network::http_request::ptr_t cleanup_request_;
-  bool etcd_ctx_enabled_;
-  bool maybe_update_internal_keepalive_topology_value_;
-  bool maybe_update_internal_keepalive_discovery_value_;
-  bool maybe_update_internal_keepalive_discovery_area_;
-  bool maybe_update_internal_keepalive_discovery_metadata_;
-  atapp_topology_info_ptr_t last_submmited_topology_data_;
-  atapp::protocol::atapp_area last_submmited_discovery_data_area_;
-  atapp::protocol::atapp_metadata last_submmited_discovery_data_metadata_;
+  atapp::protocol::atapp_etcd conf_cache_;
   atfw::util::time::time_utility::raw_time_t tick_next_timepoint_;
   std::chrono::system_clock::duration tick_interval_;
-  atapp::etcd_cluster etcd_ctx_;
-  ::atframework::atapp::etcd_response_header last_etcd_event_topology_header_;
-  ::atframework::atapp::etcd_response_header last_etcd_event_discovery_header_;
-
-  std::list<etcd_keepalive::ptr_t> internal_topology_keepalive_actors_;
-  std::list<etcd_keepalive::ptr_t> internal_discovery_keepalive_actors_;
-  std::string internal_keepalive_topology_value_;
-  std::string internal_keepalive_discovery_value_;
-
-  discovery_snapshot_event_callback_list_t discovery_on_load_snapshot_callbacks_;
-  discovery_snapshot_event_callback_list_t discovery_on_snapshot_loaded_callbacks_;
-  std::set<int64_t> discovery_watcher_snapshot_index_;
-  int64_t discovery_watcher_snapshot_index_allocator_;
-
-  mutable std::recursive_mutex discovery_watcher_callback_lock_;
-  std::list<discovery_watcher_list_callback_t> discovery_watcher_by_id_callbacks_;
-  std::list<discovery_watcher_list_callback_t> discovery_watcher_by_name_callbacks_;
-
-  topology_snapshot_event_callback_list_t topology_on_load_snapshot_callbacks_;
-  topology_snapshot_event_callback_list_t topology_on_snapshot_loaded_callbacks_;
-  std::set<int64_t> topology_watcher_snapshot_index_;
-  int64_t topology_watcher_snapshot_index_allocator_;
-
-  mutable std::recursive_mutex topology_watcher_callback_lock_;
-  std::list<topology_watcher_list_callback_t> topology_watcher_callbacks_;
-
-  etcd_watcher::ptr_t internal_topology_watcher_;
-  etcd_watcher::ptr_t internal_discovery_watcher_by_name_;
-  etcd_watcher::ptr_t internal_discovery_watcher_by_id_;
-
-  etcd_discovery_set global_discovery_;
-  std::unordered_map<uint64_t, topology_storage_t> internal_topology_info_set_;
-
-  mutable std::recursive_mutex node_event_lock_;
-  node_event_callback_list_t node_event_callbacks_;
-
-  mutable std::recursive_mutex topology_info_event_lock_;
-  topology_info_event_callback_list_t topology_info_event_callbacks_;
 };
 LIBATAPP_MACRO_NAMESPACE_END
diff --git a/include/atframe/modules/service_discovery_module.h b/include/atframe/modules/service_discovery_module.h
new file mode 100644
index 0000000..8c09a5a
--- /dev/null
+++ b/include/atframe/modules/service_discovery_module.h
@@ -0,0 +1,309 @@
+// Copyright 2026 atframework
+// Created by yousongyang
+
+#pragma once
+
+#include <config/atframe_utils_build_feature.h>
+
+#include <atframe/atapp_conf.h>
+
+#include <time/time_utility.h>
+
+#include <atframe/atapp_module_impl.h>
+
+#include <atframe/etcdcli/etcd_cluster.h>
+#include <atframe/etcdcli/etcd_discovery.h>
+#include <atframe/etcdcli/etcd_keepalive.h>
+#include <atframe/etcdcli/etcd_watcher.h>
+#include <atframe/modules/etcd_module.h>
+
+#include <list>
+#include <mutex>
+#include <string>
+#include <unordered_map>
+
+LIBATAPP_MACRO_NAMESPACE_BEGIN
+class service_discovery_module : public ::atframework::atapp::module_impl {
+ public:
+  // ============ 服务发现数据和事件相关定义 ============
+  using node_action_t = etcd_discovery_action_t;
+
+  struct LIBATAPP_MACRO_API_HEAD_ONLY node_info_t {
+    atapp::protocol::atapp_discovery node_discovery;
+    uintptr_t context_ptr = 0;
+    node_action_t action;
+  };
+
+  struct LIBATAPP_MACRO_API_HEAD_ONLY node_list_t {
+    std::list<node_info_t> nodes;
+  };
+
+  struct LIBATAPP_MACRO_API_HEAD_ONLY discovery_watcher_sender_list_t {
+    std::reference_wrapper<service_discovery_module> atapp_module;
+    std::reference_wrapper<const ::atframework::atapp::etcd_response_header> etcd_header;
+    std::reference_wrapper<const ::atframework::atapp::etcd_watcher::response_t> etcd_body;
+    std::reference_wrapper<const ::atframework::atapp::etcd_watcher::event_t> event;
+    std::reference_wrapper<const node_info_t> node;
+
+    inline discovery_watcher_sender_list_t(service_discovery_module &m,
+                                           const ::atframework::atapp::etcd_response_header &h,
+                                           const ::atframework::atapp::etcd_watcher::response_t &b,
+                                           const ::atframework::atapp::etcd_watcher::event_t &e, const node_info_t &n)
+        : atapp_module(std::ref(m)),
+          etcd_header(std::cref(h)),
+          etcd_body(std::cref(b)),
+          event(std::cref(e)),
+          node(std::cref(n)) {}
+  };
+
+  using discovery_watcher_list_callback_t = std::function<void(discovery_watcher_sender_list_t &)>;
+
+  using discovery_snapshot_event_callback_t = std::function<void(const service_discovery_module &)>;
+  using discovery_snapshot_event_callback_list_t = std::list<discovery_snapshot_event_callback_t>;
+  using discovery_snapshot_event_callback_handle_t = discovery_snapshot_event_callback_list_t::iterator;
+
+  using node_event_callback_t = std::function<void(node_action_t, const etcd_discovery_node::ptr_t &)>;
+  using node_event_callback_list_t = std::list<node_event_callback_t>;
+  using node_event_callback_handle_t = node_event_callback_list_t::iterator;
+
+  // ============ 拓扑数据和事件相关定义 ============
+  using topology_action_t = etcd_watch_event;
+  using atapp_topology_info_ptr_t = atfw::util::memory::strong_rc_ptr<atapp::protocol::atapp_topology_info>;
+
+  struct LIBATAPP_MACRO_API_HEAD_ONLY topology_storage_t {
+    atapp_topology_info_ptr_t info;
+    uintptr_t context_ptr = 0;
+    etcd_data_version version;
+  };
+
+  struct LIBATAPP_MACRO_API_HEAD_ONLY topology_info_t {
+    topology_storage_t storage;
+    topology_action_t action;
+  };
+
+  struct LIBATAPP_MACRO_API_HEAD_ONLY topology_list_t {
+    std::list<topology_info_t> topologies;
+  };
+
+  struct LIBATAPP_MACRO_API_HEAD_ONLY topology_watcher_sender_list_t {
+    std::reference_wrapper<service_discovery_module> atapp_module;
+    std::reference_wrapper<const ::atframework::atapp::etcd_response_header> etcd_header;
+    std::reference_wrapper<const ::atframework::atapp::etcd_watcher::response_t> etcd_body;
+    std::reference_wrapper<const ::atframework::atapp::etcd_watcher::event_t> event;
+    std::reference_wrapper<const topology_info_t> topology;
+
+    inline topology_watcher_sender_list_t(service_discovery_module &m,
+                                          const ::atframework::atapp::etcd_response_header &h,
+                                          const ::atframework::atapp::etcd_watcher::response_t &b,
+                                          const ::atframework::atapp::etcd_watcher::event_t &e,
+                                          const topology_info_t &n)
+        : atapp_module(std::ref(m)),
+          etcd_header(std::cref(h)),
+          etcd_body(std::cref(b)),
+          event(std::cref(e)),
+          topology(std::cref(n)) {}
+  };
+
+  using topology_watcher_list_callback_t = std::function<void(topology_watcher_sender_list_t &)>;
+
+  using topology_snapshot_event_callback_t = std::function<void(const service_discovery_module &)>;
+  using topology_snapshot_event_callback_list_t = std::list<topology_snapshot_event_callback_t>;
+  using topology_snapshot_event_callback_handle_t = topology_snapshot_event_callback_list_t::iterator;
+
+  using topology_info_event_callback_t =
+      std::function<void(topology_action_t, const atapp_topology_info_ptr_t &, const etcd_data_version &)>;
+  using topology_info_event_callback_list_t = std::list<topology_info_event_callback_t>;
+  using topology_info_event_callback_handle_t = topology_info_event_callback_list_t::iterator;
+
+  struct service_discovery_cluster_context_data;
+
+  class service_discovery_cluster_context {
+   public:
+    friend class service_discovery_module;
+
+    LIBATAPP_MACRO_API service_discovery_cluster_context();
+    LIBATAPP_MACRO_API int init(atframework::atapp::app &app, const atapp::protocol::atapp_etcd &conf,
+                                const atapp::protocol::atapp_log *ATFW_UTIL_MACRO_NULLABLE log_conf);
+    LIBATAPP_MACRO_API int reload(const atapp::protocol::atapp_etcd &conf,
+                                  const atapp::protocol::atapp_log *ATFW_UTIL_MACRO_NULLABLE log_conf);
+    LIBATAPP_MACRO_API int stop();
+    LIBATAPP_MACRO_API void tick();
+
+   public:
+    LIBATAPP_MACRO_API etcd_module &get_etcd_module();
+    LIBATAPP_MACRO_API const etcd_module &get_etcd_module() const;
+
+    LIBATAPP_MACRO_API bool check_keepalive_actor_start_success();
+    LIBATAPP_MACRO_API void add_discovery_watcher_by_id_callback(const discovery_watcher_list_callback_t &fn);
+    LIBATAPP_MACRO_API void add_discovery_watcher_by_name_callback(const discovery_watcher_list_callback_t &fn);
+    LIBATAPP_MACRO_API void add_topology_watcher_callback(const topology_watcher_list_callback_t &fn);
+
+    LIBATAPP_MACRO_API void reset_internal_watchers_and_keepalives();
+
+   private:
+    etcd_module etcd_module_;
+    ::atfw::util::nostd::nonnull<std::shared_ptr<service_discovery_cluster_context_data>> data_;
+  };
+
+ public:
+  LIBATAPP_MACRO_API service_discovery_module();
+
+ private:
+  void update_keepalive_topology_value();
+  void update_keepalive_discovery_value();
+
+ public:
+  LIBATAPP_MACRO_API int init() override;
+  LIBATAPP_MACRO_API const char *ATFW_UTIL_MACRO_NONNULL name() const override;
+  LIBATAPP_MACRO_API int stop() override;
+  LIBATAPP_MACRO_API int reload() override;
+  LIBATAPP_MACRO_API int tick() override;
+
+ public:
+  LIBATAPP_MACRO_API bool is_discovery_enabled() const;
+  LIBATAPP_MACRO_API void enable_discovery();
+  LIBATAPP_MACRO_API void disable_discovery();
+
+  LIBATAPP_MACRO_API void set_maybe_update_keepalive_topology_value();
+  LIBATAPP_MACRO_API void set_maybe_update_keepalive_discovery_value();
+  LIBATAPP_MACRO_API void set_maybe_update_keepalive_discovery_area();
+  LIBATAPP_MACRO_API void set_maybe_update_keepalive_discovery_metadata();
+
+  LIBATAPP_MACRO_API static std::string get_discovery_by_id_path(atframework::atapp::app &app, const std::string &path);
+  LIBATAPP_MACRO_API static std::string get_discovery_by_name_path(atframework::atapp::app &app,
+                                                                   const std::string &path);
+  LIBATAPP_MACRO_API static std::string get_topology_path(atframework::atapp::app &app, const std::string &path);
+
+  LIBATAPP_MACRO_API static std::string get_discovery_by_id_watcher_path(atframework::atapp::app &app,
+                                                                         const std::string &path);
+  LIBATAPP_MACRO_API static std::string get_discovery_by_name_watcher_path(atframework::atapp::app &app,
+                                                                           const std::string &path);
+  LIBATAPP_MACRO_API static std::string get_topology_watcher_path(atframework::atapp::app &app,
+                                                                  const std::string &path);
+
+  LIBATAPP_MACRO_API int init_service_discovery_keepalives_watchers(service_discovery_cluster_context &context);
+
+  LIBATAPP_MACRO_API static int init_discovery_watcher_by_id(atframework::atapp::app &app,
+                                                             service_discovery_cluster_context &context);
+  LIBATAPP_MACRO_API static int init_discovery_watcher_by_name(atframework::atapp::app &app,
+                                                               service_discovery_cluster_context &context);
+  LIBATAPP_MACRO_API static int init_topology_watcher(atframework::atapp::app &app,
+                                                      service_discovery_cluster_context &context);
+  LIBATAPP_MACRO_API static int init_discovery_keepalive_by_id(atframework::atapp::app &app,
+                                                               service_discovery_cluster_context &context,
+                                                               std::string &value);
+  LIBATAPP_MACRO_API static int init_discovery_keepalive_by_name(atframework::atapp::app &app,
+                                                                 service_discovery_cluster_context &context,
+                                                                 std::string &value);
+  LIBATAPP_MACRO_API static int init_topology_keepalive(atframework::atapp::app &app,
+                                                        service_discovery_cluster_context &context, std::string &value);
+
+  LIBATAPP_MACRO_API int add_discovery_watcher_by_id_callback(const discovery_watcher_list_callback_t &fn);
+  LIBATAPP_MACRO_API int add_discovery_watcher_by_name_callback(const discovery_watcher_list_callback_t &fn);
+  LIBATAPP_MACRO_API int add_topology_watcher_callback(const topology_watcher_list_callback_t &fn);
+
+  LIBATAPP_MACRO_API const ::atframework::atapp::etcd_cluster &get_raw_etcd_ctx() const;
+  LIBATAPP_MACRO_API ::atframework::atapp::etcd_cluster &get_raw_etcd_ctx();
+
+  LIBATAPP_MACRO_API const ::atframework::atapp::etcd_response_header &get_last_etcd_event_topology_header()
+      const noexcept;
+  LIBATAPP_MACRO_API const ::atframework::atapp::etcd_response_header &get_last_etcd_event_discovery_header()
+      const noexcept;
+
+  LIBATAPP_MACRO_API const atapp::protocol::atapp_etcd &get_configure() const;
+  LIBATAPP_MACRO_API const std::string &get_configure_path();
+
+  LIBATAPP_MACRO_API static atapp::etcd_keepalive::ptr_t add_keepalive_actor(atframework::atapp::app &app,
+                                                                             service_discovery_cluster_context &context,
+                                                                             std::string &val,
+                                                                             const std::string &node_path);
+  LIBATAPP_MACRO_API atapp::etcd_keepalive::ptr_t add_keepalive_actor(atframework::atapp::app &app, std::string &val,
+                                                                      const std::string &node_path);
+
+  LIBATAPP_MACRO_API static bool remove_keepalive_actor(atframework::atapp::app &app,
+                                                        service_discovery_cluster_context &context,
+                                                        const atapp::etcd_keepalive::ptr_t &keepalive);
+  LIBATAPP_MACRO_API bool remove_keepalive_actor(atframework::atapp::app &app,
+                                                 const atapp::etcd_keepalive::ptr_t &keepalive);
+
+  LIBATAPP_MACRO_API node_event_callback_handle_t add_on_node_discovery_event(const node_event_callback_t &fn);
+  LIBATAPP_MACRO_API void remove_on_node_event(node_event_callback_handle_t &handle);
+
+  LIBATAPP_MACRO_API topology_info_event_callback_handle_t
+  add_on_topology_info_event(const topology_info_event_callback_t &fn);
+  LIBATAPP_MACRO_API void remove_on_topology_info_event(topology_info_event_callback_handle_t &handle);
+
+  LIBATAPP_MACRO_API etcd_discovery_set &get_global_discovery() noexcept;
+  LIBATAPP_MACRO_API const etcd_discovery_set &get_global_discovery() const noexcept;
+
+  LIBATAPP_MACRO_API const std::unordered_map<uint64_t, topology_storage_t> &get_topology_info_set() const noexcept;
+
+  LIBATAPP_MACRO_API bool has_discovery_snapshot() const noexcept;
+
+  LIBATAPP_MACRO_API discovery_snapshot_event_callback_handle_t
+  add_on_load_discovery_snapshot(const discovery_snapshot_event_callback_t &fn);
+  LIBATAPP_MACRO_API void remove_on_load_discovery_snapshot(discovery_snapshot_event_callback_handle_t &handle);
+  LIBATAPP_MACRO_API discovery_snapshot_event_callback_handle_t
+  add_on_discovery_snapshot_loaded(const discovery_snapshot_event_callback_t &fn);
+  LIBATAPP_MACRO_API void remove_on_discovery_snapshot_loaded(discovery_snapshot_event_callback_handle_t &handle);
+
+  LIBATAPP_MACRO_API bool has_topology_snapshot() const noexcept;
+
+  LIBATAPP_MACRO_API topology_snapshot_event_callback_handle_t
+  add_on_load_topology_snapshot(const topology_snapshot_event_callback_t &fn);
+  LIBATAPP_MACRO_API void remove_on_load_topology_snapshot(topology_snapshot_event_callback_handle_t &handle);
+  LIBATAPP_MACRO_API topology_snapshot_event_callback_handle_t
+  add_on_topology_snapshot_loaded(const topology_snapshot_event_callback_t &fn);
+  LIBATAPP_MACRO_API void remove_on_topology_snapshot_loaded(topology_snapshot_event_callback_handle_t &handle);
+
+  LIBATAPP_MACRO_API etcd_watcher::watch_event_fn_t_ptr create_discovery_watcher_callback_list_wrapper(
+      service_discovery_cluster_context &context);
+  LIBATAPP_MACRO_API etcd_watcher::watch_event_fn_t_ptr create_topology_watcher_callback_list_wrapper(
+      service_discovery_cluster_context &context);
+
+ private:
+  static bool unpack(node_info_t &out, const std::string &path, const std::string &json, bool reset_data);
+  static void pack(const node_info_t &src, std::string &json);
+  static bool unpack(topology_info_t &out, const std::string &path, const std::string &json, bool reset_data);
+  static void pack(const atapp::protocol::atapp_topology_info &src, std::string &json);
+
+  struct topology_watcher_callback_list_wrapper_t;
+  struct discovery_watcher_callback_list_wrapper_t;
+
+  bool update_internal_watcher_event(node_info_t &node, const etcd_discovery_node::node_version &version);
+  bool update_internal_watcher_event(topology_info_t &topology_info);
+
+  struct watcher_internal_access_t;
+
+ private:
+  bool discovery_enabled_;
+  service_discovery_cluster_context cluster_context_;
+
+  bool maybe_update_internal_keepalive_topology_value_;
+  bool maybe_update_internal_keepalive_discovery_value_;
+  bool maybe_update_internal_keepalive_discovery_area_;
+  bool maybe_update_internal_keepalive_discovery_metadata_;
+
+  atapp_topology_info_ptr_t last_submitted_topology_data_;
+  atapp::protocol::atapp_area last_submitted_discovery_data_area_;
+  atapp::protocol::atapp_metadata last_submitted_discovery_data_metadata_;
+
+  std::string internal_keepalive_topology_value_;
+  std::string internal_keepalive_discovery_value_;
+
+  discovery_snapshot_event_callback_list_t discovery_on_load_snapshot_callbacks_;
+  discovery_snapshot_event_callback_list_t discovery_on_snapshot_loaded_callbacks_;
+
+  topology_snapshot_event_callback_list_t topology_on_load_snapshot_callbacks_;
+  topology_snapshot_event_callback_list_t topology_on_snapshot_loaded_callbacks_;
+
+  etcd_discovery_set global_discovery_;
+  std::unordered_map<uint64_t, topology_storage_t> internal_topology_info_set_;
+
+  mutable std::recursive_mutex node_event_lock_;
+  node_event_callback_list_t node_event_callbacks_;
+
+  mutable std::recursive_mutex topology_info_event_lock_;
+  topology_info_event_callback_list_t topology_info_event_callbacks_;
+};
+LIBATAPP_MACRO_NAMESPACE_END
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index fee7a52..7ab10fb 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -24,6 +24,7 @@ set(PROJECT_LIBATAPP_SRC_LIST
     "${PROJECT_LIBATAPP_ROOT_INC_DIR}/atframe/etcdcli/etcd_packer.h"
     "${PROJECT_LIBATAPP_ROOT_INC_DIR}/atframe/etcdcli/etcd_watcher.h"
     "${PROJECT_LIBATAPP_ROOT_INC_DIR}/atframe/modules/etcd_module.h"
+    "${PROJECT_LIBATAPP_ROOT_INC_DIR}/atframe/modules/service_discovery_module.h"
     "${PROJECT_LIBATAPP_ROOT_INC_DIR}/atframe/modules/worker_context.h"
     "${PROJECT_LIBATAPP_ROOT_INC_DIR}/atframe/modules/worker_pool_module.h"
     "${CMAKE_CURRENT_LIST_DIR}/atframe/atapp.cpp"
@@ -42,6 +43,7 @@ set(PROJECT_LIBATAPP_SRC_LIST
     "${CMAKE_CURRENT_LIST_DIR}/atframe/etcdcli/etcd_packer.cpp"
     "${CMAKE_CURRENT_LIST_DIR}/atframe/etcdcli/etcd_watcher.cpp"
     "${CMAKE_CURRENT_LIST_DIR}/atframe/modules/etcd_module.cpp"
+    "${CMAKE_CURRENT_LIST_DIR}/atframe/modules/service_discovery_module.cpp"
     "${CMAKE_CURRENT_LIST_DIR}/atframe/modules/worker_pool_module.cpp")
 
 source_group(TREE "${PROJECT_SOURCE_DIR}" FILES ${PROJECT_LIBATAPP_SRC_LIST})
diff --git a/src/atframe/atapp.cpp b/src/atframe/atapp.cpp
index 3a1ff74..dbe2be8 100644
--- a/src/atframe/atapp.cpp
+++ b/src/atframe/atapp.cpp
@@ -46,7 +46,7 @@
 
 #include "atframe/atapp_conf_rapidjson.h"
 #include "atframe/atapp_windows_minidump.h"
-#include "atframe/modules/etcd_module.h"
+#include "atframe/modules/service_discovery_module.h"
 #include "atframe/modules/worker_pool_module.h"
 
 #include "atframe/connectors/atapp_connector_atbus.h"
@@ -325,6 +325,23 @@ static std::chrono::system_clock::duration &atapp_get_sys_now_offset() {
 
 }  // namespace
 
+struct ATFW_UTIL_SYMBOL_LOCAL curl_multi_guard_type {
+  curl_multi_guard_type() { init_result = curl_global_init(CURL_GLOBAL_ALL); }
+  ~curl_multi_guard_type() {
+    if (init_result == 0) {
+      curl_global_cleanup();
+    }
+  }
+  int init_result;
+};
+static std::shared_ptr<curl_multi_guard_type> create_curl_multi_guard() {
+  std::shared_ptr<curl_multi_guard_type> guard = std::make_shared<curl_multi_guard_type>();
+  if (guard->init_result != 0) {
+    return nullptr;
+  }
+  return guard;
+}
+
 LIBATAPP_MACRO_API app::message_t::message_t() : type(0), message_sequence(0), metadata(nullptr) {}
 LIBATAPP_MACRO_API app::message_t::~message_t() {}
 
@@ -441,8 +458,8 @@ LIBATAPP_MACRO_API app::app()
   // internal modules
   internal_module_worker_pool_ = std::make_shared<atapp::worker_pool_module>();
   add_module(internal_module_worker_pool_);
-  internal_module_etcd_ = std::make_shared<atapp::etcd_module>();
-  add_module(internal_module_etcd_);
+  internal_module_service_discovery_ = std::make_shared<atapp::service_discovery_module>();
+  add_module(internal_module_service_discovery_);
 
   atapp_global_init_once();
 }
@@ -532,6 +549,12 @@ LIBATAPP_MACRO_API app::~app() {
     bus_node_.reset();
   }
 
+  // reset curl multi
+  if (curl_multi_) {
+    atfw::util::network::http_request::destroy_curl_multi(curl_multi_);
+  }
+  curl_multi_guard_ = nullptr;
+
   // finally events
   app_evt_on_finally();
 
@@ -716,6 +739,14 @@ LIBATAPP_MACRO_API int app::init(ev_loop_t *ev_loop, int argc, const char **argv
     return setup_result_ = ret;
   }
 
+  ret = setup_curl_multi();
+  if (ret < 0) {
+    FWLOGERROR("setup curl multi failed");
+    bus_node_.reset();
+    write_startup_error_file(ret);
+    return setup_result_ = ret;
+  }
+
   // all modules reload
   stats_.module_reload.clear();
   stats_.module_reload.reserve(modules_.size());
@@ -1202,9 +1233,9 @@ LIBATAPP_MACRO_API int app::reload() {
       }
     }
 
-    if (internal_module_etcd_) {
-      internal_module_etcd_->set_maybe_update_keepalive_topology_value();
-      internal_module_etcd_->set_maybe_update_keepalive_discovery_value();
+    if (internal_module_service_discovery_) {
+      internal_module_service_discovery_->set_maybe_update_keepalive_topology_value();
+      internal_module_service_discovery_->set_maybe_update_keepalive_discovery_value();
     }
   }
 
@@ -1361,9 +1392,9 @@ LIBATAPP_MACRO_API int app::tick() {
               (static_cast<float>(atfw::util::time::time_utility::MINITE_SECONDS) * 10000.0f),  // usec and add %
           max_rss.first, max_rss.second, ru_ixrss.first, ru_ixrss.second, ru_idrss.first, ru_idrss.second,
           ru_isrss.first, ru_isrss.second, last_usage.ru_majflt);
-      if (internal_module_etcd_) {
+      if (internal_module_service_discovery_) {
         const ::atframework::atapp::etcd_cluster::stats_t &current =
-            internal_module_etcd_->get_raw_etcd_ctx().get_stats();
+            internal_module_service_discovery_->get_raw_etcd_ctx().get_stats();
         FWLOGINFO(
             "\tetcd module(last minite): request count: {}, failed request: {}, continue failed: {}, success "
             "request: "
@@ -1388,8 +1419,8 @@ LIBATAPP_MACRO_API int app::tick() {
 #endif
     } else {
       uv_getrusage(&stats_.last_checkpoint_usage);
-      if (internal_module_etcd_) {
-        stats_.internal_etcd = internal_module_etcd_->get_raw_etcd_ctx().get_stats();
+      if (internal_module_service_discovery_) {
+        stats_.internal_etcd = internal_module_service_discovery_->get_raw_etcd_ctx().get_stats();
       }
     }
 
@@ -1446,11 +1477,7 @@ LIBATAPP_MACRO_API bool app::is_current_upgrade_mode() const noexcept { return c
 
 LIBATAPP_MACRO_API atfw::util::network::http_request::curl_m_bind_ptr_t app::get_shared_curl_multi_context()
     const noexcept {
-  if ATFW_UTIL_LIKELY_CONDITION (internal_module_etcd_) {
-    return internal_module_etcd_->get_shared_curl_multi_context();
-  }
-
-  return nullptr;
+  return curl_multi_;
 }
 
 LIBATAPP_MACRO_API void app::set_app_version(const std::string &ver) { conf_.app_version = ver; }
@@ -1666,8 +1693,8 @@ LIBATAPP_MACRO_API void app::set_api_version(gsl::string_view value) {
     return;
   }
 
-  if (internal_module_etcd_) {
-    internal_module_etcd_->set_maybe_update_keepalive_discovery_metadata();
+  if (internal_module_service_discovery_) {
+    internal_module_service_discovery_->set_maybe_update_keepalive_discovery_metadata();
   }
 
   conf_.metadata.set_api_version(value.data(), value.size());
@@ -1678,8 +1705,8 @@ LIBATAPP_MACRO_API void app::set_kind(gsl::string_view value) {
     return;
   }
 
-  if (internal_module_etcd_) {
-    internal_module_etcd_->set_maybe_update_keepalive_discovery_metadata();
+  if (internal_module_service_discovery_) {
+    internal_module_service_discovery_->set_maybe_update_keepalive_discovery_metadata();
   }
 
   conf_.metadata.set_kind(value.data(), value.size());
@@ -1690,8 +1717,8 @@ LIBATAPP_MACRO_API void app::set_group(gsl::string_view value) {
     return;
   }
 
-  if (internal_module_etcd_) {
-    internal_module_etcd_->set_maybe_update_keepalive_discovery_metadata();
+  if (internal_module_service_discovery_) {
+    internal_module_service_discovery_->set_maybe_update_keepalive_discovery_metadata();
   }
 
   conf_.metadata.set_group(value.data(), value.size());
@@ -1702,8 +1729,8 @@ LIBATAPP_MACRO_API void app::set_metadata_name(gsl::string_view value) {
     return;
   }
 
-  if (internal_module_etcd_) {
-    internal_module_etcd_->set_maybe_update_keepalive_discovery_metadata();
+  if (internal_module_service_discovery_) {
+    internal_module_service_discovery_->set_maybe_update_keepalive_discovery_metadata();
   }
 
   conf_.metadata.set_name(value.data(), value.size());
@@ -1715,8 +1742,8 @@ LIBATAPP_MACRO_API void app::set_metadata_namespace_name(gsl::string_view value)
     return;
   }
 
-  if (internal_module_etcd_) {
-    internal_module_etcd_->set_maybe_update_keepalive_discovery_metadata();
+  if (internal_module_service_discovery_) {
+    internal_module_service_discovery_->set_maybe_update_keepalive_discovery_metadata();
   }
 
   conf_.metadata.set_namespace_name(value.data(), value.size());
@@ -1727,8 +1754,8 @@ LIBATAPP_MACRO_API void app::set_metadata_uid(gsl::string_view value) {
     return;
   }
 
-  if (internal_module_etcd_) {
-    internal_module_etcd_->set_maybe_update_keepalive_discovery_metadata();
+  if (internal_module_service_discovery_) {
+    internal_module_service_discovery_->set_maybe_update_keepalive_discovery_metadata();
   }
 
   conf_.metadata.set_uid(value.data(), value.size());
@@ -1739,8 +1766,8 @@ LIBATAPP_MACRO_API void app::set_metadata_service_subset(gsl::string_view value)
     return;
   }
 
-  if (internal_module_etcd_) {
-    internal_module_etcd_->set_maybe_update_keepalive_discovery_metadata();
+  if (internal_module_service_discovery_) {
+    internal_module_service_discovery_->set_maybe_update_keepalive_discovery_metadata();
   }
 
   conf_.metadata.set_service_subset(value.data(), value.size());
@@ -1762,8 +1789,8 @@ LIBATAPP_MACRO_API void app::set_metadata_label(gsl::string_view key, gsl::strin
     return;
   }
 
-  if (internal_module_etcd_) {
-    internal_module_etcd_->set_maybe_update_keepalive_discovery_metadata();
+  if (internal_module_service_discovery_) {
+    internal_module_service_discovery_->set_maybe_update_keepalive_discovery_metadata();
   }
 
   (*labels)[key_string] = static_cast<std::string>(value);
@@ -1803,8 +1830,8 @@ LIBATAPP_MACRO_API int32_t app::get_runtime_stateful_pod_index() const noexcept
 LIBATAPP_MACRO_API const atapp::protocol::atapp_area &app::get_area() const noexcept { return conf_.origin.area(); }
 
 LIBATAPP_MACRO_API atapp::protocol::atapp_area &app::mutable_area() {
-  if (internal_module_etcd_) {
-    internal_module_etcd_->set_maybe_update_keepalive_discovery_area();
+  if (internal_module_service_discovery_) {
+    internal_module_service_discovery_->set_maybe_update_keepalive_discovery_area();
   }
   return *conf_.origin.mutable_area();
 }
@@ -1882,8 +1909,9 @@ LIBATAPP_MACRO_API void app::pack(atapp::protocol::atapp_discovery &out) const {
   }
 }
 
-LIBATAPP_MACRO_API const std::shared_ptr<::atframework::atapp::etcd_module> &app::get_etcd_module() const noexcept {
-  return internal_module_etcd_;
+LIBATAPP_MACRO_API const std::shared_ptr<::atframework::atapp::service_discovery_module> &
+app::get_service_discovery_module() const noexcept {
+  return internal_module_service_discovery_;
 }
 
 LIBATAPP_MACRO_API const std::shared_ptr<::atframework::atapp::worker_pool_module> &app::get_worker_pool_module()
@@ -1892,8 +1920,8 @@ LIBATAPP_MACRO_API const std::shared_ptr<::atframework::atapp::worker_pool_modul
 }
 
 LIBATAPP_MACRO_API const etcd_discovery_set &app::get_global_discovery() const noexcept {
-  if (internal_module_etcd_) {
-    return internal_module_etcd_->get_global_discovery();
+  if (internal_module_service_discovery_) {
+    return internal_module_service_discovery_->get_global_discovery();
   }
 
   return internal_empty_discovery_set_;
@@ -1965,19 +1993,19 @@ LIBATAPP_MACRO_API uint32_t app::get_address_type(const std::string &address) co
 }
 
 LIBATAPP_MACRO_API etcd_discovery_node::ptr_t app::get_discovery_node_by_id(uint64_t id) const noexcept {
-  if (!internal_module_etcd_) {
+  if (!internal_module_service_discovery_) {
     return nullptr;
   }
 
-  return internal_module_etcd_->get_global_discovery().get_node_by_id(id);
+  return internal_module_service_discovery_->get_global_discovery().get_node_by_id(id);
 }
 
 LIBATAPP_MACRO_API etcd_discovery_node::ptr_t app::get_discovery_node_by_name(const std::string &name) const noexcept {
-  if (!internal_module_etcd_) {
+  if (!internal_module_service_discovery_) {
     return nullptr;
   }
 
-  return internal_module_etcd_->get_global_discovery().get_node_by_name(name);
+  return internal_module_service_discovery_->get_global_discovery().get_node_by_name(name);
 }
 
 LIBATAPP_MACRO_API void app::produce_tick_timer_compensation(std::chrono::system_clock::duration tick_cost) noexcept {
@@ -2068,11 +2096,12 @@ LIBATAPP_MACRO_API int32_t app::send_message(uint64_t target_node_id, int32_t ty
 
   // Try to create endpoint from discovery
   do {
-    if (!internal_module_etcd_) {
+    if (!internal_module_service_discovery_) {
       break;
     }
 
-    etcd_discovery_node::ptr_t node = internal_module_etcd_->get_global_discovery().get_node_by_id(target_node_id);
+    etcd_discovery_node::ptr_t node =
+        internal_module_service_discovery_->get_global_discovery().get_node_by_id(target_node_id);
     if (!node) {
       break;
     }
@@ -2128,11 +2157,12 @@ LIBATAPP_MACRO_API int32_t app::send_message(const std::string &target_node_name
   } while (false);
 
   // Try to create endpoint from discovery
-  if (!internal_module_etcd_) {
+  if (!internal_module_service_discovery_) {
     return EN_ATAPP_ERR_DISCOVERY_DISABLED;
   }
 
-  etcd_discovery_node::ptr_t node = internal_module_etcd_->get_global_discovery().get_node_by_name(target_node_name);
+  etcd_discovery_node::ptr_t node =
+      internal_module_service_discovery_->get_global_discovery().get_node_by_name(target_node_name);
   if (!node) {
     return EN_ATBUS_ERR_ATNODE_NOT_FOUND;
   }
@@ -2170,68 +2200,70 @@ LIBATAPP_MACRO_API int32_t app::send_message_by_consistent_hash(gsl::span<const
                                                                 gsl::span<const unsigned char> data,
                                                                 uint64_t *msg_sequence,
                                                                 const atapp::protocol::atapp_metadata *metadata) {
-  if (!internal_module_etcd_) {
+  if (!internal_module_service_discovery_) {
     return EN_ATAPP_ERR_DISCOVERY_DISABLED;
   }
 
-  return send_message_by_consistent_hash(internal_module_etcd_->get_global_discovery(), hash_buf, type, data,
-                                         msg_sequence, metadata);
+  return send_message_by_consistent_hash(internal_module_service_discovery_->get_global_discovery(), hash_buf, type,
+                                         data, msg_sequence, metadata);
 }
 
 LIBATAPP_MACRO_API int32_t app::send_message_by_consistent_hash(uint64_t hash_key, int32_t type,
                                                                 gsl::span<const unsigned char> data,
                                                                 uint64_t *msg_sequence,
                                                                 const atapp::protocol::atapp_metadata *metadata) {
-  if (!internal_module_etcd_) {
+  if (!internal_module_service_discovery_) {
     return EN_ATAPP_ERR_DISCOVERY_DISABLED;
   }
 
-  return send_message_by_consistent_hash(internal_module_etcd_->get_global_discovery(), hash_key, type, data,
-                                         msg_sequence, metadata);
+  return send_message_by_consistent_hash(internal_module_service_discovery_->get_global_discovery(), hash_key, type,
+                                         data, msg_sequence, metadata);
 }
 
 LIBATAPP_MACRO_API int32_t app::send_message_by_consistent_hash(int64_t hash_key, int32_t type,
                                                                 gsl::span<const unsigned char> data,
                                                                 uint64_t *msg_sequence,
                                                                 const atapp::protocol::atapp_metadata *metadata) {
-  if (!internal_module_etcd_) {
+  if (!internal_module_service_discovery_) {
     return EN_ATAPP_ERR_DISCOVERY_DISABLED;
   }
 
-  return send_message_by_consistent_hash(internal_module_etcd_->get_global_discovery(), hash_key, type, data,
-                                         msg_sequence, metadata);
+  return send_message_by_consistent_hash(internal_module_service_discovery_->get_global_discovery(), hash_key, type,
+                                         data, msg_sequence, metadata);
 }
 
 LIBATAPP_MACRO_API int32_t app::send_message_by_consistent_hash(const std::string &hash_key, int32_t type,
                                                                 gsl::span<const unsigned char> data,
                                                                 uint64_t *msg_sequence,
                                                                 const atapp::protocol::atapp_metadata *metadata) {
-  if (!internal_module_etcd_) {
+  if (!internal_module_service_discovery_) {
     return EN_ATAPP_ERR_DISCOVERY_DISABLED;
   }
 
-  return send_message_by_consistent_hash(internal_module_etcd_->get_global_discovery(), hash_key, type, data,
-                                         msg_sequence, metadata);
+  return send_message_by_consistent_hash(internal_module_service_discovery_->get_global_discovery(), hash_key, type,
+                                         data, msg_sequence, metadata);
 }
 
 LIBATAPP_MACRO_API int32_t app::send_message_by_random(int32_t type, gsl::span<const unsigned char> data,
                                                        uint64_t *msg_sequence,
                                                        const atapp::protocol::atapp_metadata *metadata) {
-  if (!internal_module_etcd_) {
+  if (!internal_module_service_discovery_) {
     return EN_ATAPP_ERR_DISCOVERY_DISABLED;
   }
 
-  return send_message_by_random(internal_module_etcd_->get_global_discovery(), type, data, msg_sequence, metadata);
+  return send_message_by_random(internal_module_service_discovery_->get_global_discovery(), type, data, msg_sequence,
+                                metadata);
 }
 
 LIBATAPP_MACRO_API int32_t app::send_message_by_round_robin(int32_t type, gsl::span<const unsigned char> data,
                                                             uint64_t *msg_sequence,
                                                             const atapp::protocol::atapp_metadata *metadata) {
-  if (!internal_module_etcd_) {
+  if (!internal_module_service_discovery_) {
     return EN_ATAPP_ERR_DISCOVERY_DISABLED;
   }
 
-  return send_message_by_round_robin(internal_module_etcd_->get_global_discovery(), type, data, msg_sequence, metadata);
+  return send_message_by_round_robin(internal_module_service_discovery_->get_global_discovery(), type, data,
+                                     msg_sequence, metadata);
 }
 
 LIBATAPP_MACRO_API int32_t app::send_message_by_consistent_hash(const etcd_discovery_set &discovery_set,
@@ -3252,7 +3284,7 @@ atapp_endpoint::ptr_t app::auto_mutable_self_endpoint() {
 
   atapp::protocol::atapp_discovery self_discovery_info;
   pack(self_discovery_info);
-  self_discovery->copy_from(self_discovery_info, atapp::etcd_discovery_node::node_version());
+  self_discovery->copy_from(self_discovery_info, atapp::etcd_discovery_node::node_version(), 0);
 
   return mutable_endpoint(self_discovery);
 }
@@ -4096,6 +4128,28 @@ int app::setup_atbus() {
   return 0;
 }
 
+int app::setup_curl_multi() {
+  // init curl
+  curl_multi_guard_ = create_curl_multi_guard();
+  if (curl_multi_guard_ == nullptr) {
+    FWLOGERROR("init curl multi guard failed");
+    return -1;
+  }
+
+  atfw::util::network::http_request::curl_share_options share_options;
+  atfw::util::network::http_request::curl_multi_options multi_options;
+  multi_options.ev_loop = get_bus_node()->get_evloop();
+  // Share DNS cache, connection, TLS sessions and etc.
+  atfw::util::network::http_request::create_curl_share(share_options, multi_options.share_context);
+  atfw::util::network::http_request::create_curl_multi(get_bus_node()->get_evloop(), curl_multi_);
+  if (!curl_multi_) {
+    FWLOGERROR("create curl multi instance failed.");
+    curl_multi_guard_ = nullptr;
+    return -1;
+  }
+  return 0;
+}
+
 void app::close_timer(timer_ptr_t &t) {
   // if timer is maintained by a RAII guard, just ignore.
   if (t) {
@@ -4799,13 +4853,13 @@ int app::command_handler_invalid(atfw::util::cli::callback_param params) {
   return 0;
 }
 
-int app::command_handler_disable_etcd(atfw::util::cli::callback_param params) {
-  if (!internal_module_etcd_) {
+int app::command_handler_disable_discovery(atfw::util::cli::callback_param params) {
+  if (!internal_module_service_discovery_) {
     const char *msg = "Etcd module is not initialized, skip command.";
     FWLOGERROR("{}", msg);
     add_custom_command_rsp(params, msg);
-  } else if (internal_module_etcd_->is_etcd_enabled()) {
-    internal_module_etcd_->disable_etcd();
+  } else if (internal_module_service_discovery_->is_discovery_enabled()) {
+    internal_module_service_discovery_->disable_discovery();
     const char *msg = "Etcd context is disabled now.";
     FWLOGINFO("{}", msg);
     add_custom_command_rsp(params, msg);
@@ -4817,18 +4871,18 @@ int app::command_handler_disable_etcd(atfw::util::cli::callback_param params) {
   return 0;
 }
 
-int app::command_handler_enable_etcd(atfw::util::cli::callback_param params) {
-  if (!internal_module_etcd_) {
+int app::command_handler_enable_discovery(atfw::util::cli::callback_param params) {
+  if (!internal_module_service_discovery_) {
     const char *msg = "Etcd module not initialized, skip command.";
     FWLOGERROR("{}", msg);
     add_custom_command_rsp(params, msg);
-  } else if (internal_module_etcd_->is_etcd_enabled()) {
+  } else if (internal_module_service_discovery_->is_discovery_enabled()) {
     const char *msg = "Etcd context is already enabled, skip command.";
     FWLOGERROR("{}", msg);
     add_custom_command_rsp(params, msg);
   } else {
-    internal_module_etcd_->enable_etcd();
-    if (internal_module_etcd_->is_etcd_enabled()) {
+    internal_module_service_discovery_->enable_discovery();
+    if (internal_module_service_discovery_->is_discovery_enabled()) {
       const char *msg = "Etcd context is enabled now.";
       FWLOGINFO("{}", msg);
       add_custom_command_rsp(params, msg);
@@ -4843,8 +4897,8 @@ int app::command_handler_enable_etcd(atfw::util::cli::callback_param params) {
 }
 
 int app::command_handler_list_discovery(atfw::util::cli::callback_param params) {
-  if (!internal_module_etcd_) {
-    const char *msg = "Etcd module not initialized.";
+  if (!internal_module_service_discovery_) {
+    const char *msg = "Service discovery module not initialized.";
     add_custom_command_rsp(params, msg);
   } else {
     size_t start_idx = 0;
@@ -4857,7 +4911,7 @@ int app::command_handler_list_discovery(atfw::util::cli::callback_param params)
     }
 
     const std::vector<etcd_discovery_node::ptr_t> &nodes =
-        internal_module_etcd_->get_global_discovery().get_sorted_nodes();
+        internal_module_service_discovery_->get_global_discovery().get_sorted_nodes();
     for (size_t i = start_idx; i < nodes.size() && (0 == end_idx || i < end_idx); ++i) {
       if (!nodes[i]) {
         continue;
@@ -5282,13 +5336,12 @@ void app::setup_command() {
   cmd_mgr->bind_cmd("stop", &app::app::command_handler_stop, this);
   // reload all configures
   cmd_mgr->bind_cmd("reload", &app::app::command_handler_reload, this);
-  // enable etcd
-  cmd_mgr->bind_cmd("enable-etcd", &app::command_handler_enable_etcd, this)
-      ->set_help_msg("enable-etcd                            enable etcd discovery module.");
-
-  // disable etcd
-  cmd_mgr->bind_cmd("disable-etcd", &app::command_handler_disable_etcd, this)
-      ->set_help_msg("disable-etcd                           disable etcd discovery module.");
+  // enable discovery
+  cmd_mgr->bind_cmd("enable-discovery", &app::command_handler_enable_discovery, this)
+      ->set_help_msg("enable-discovery                            enable etcd discovery module.");
+  // disable discovery
+  cmd_mgr->bind_cmd("disable-discovery", &app::command_handler_disable_discovery, this)
+      ->set_help_msg("disable-discovery                           disable etcd discovery module.");
 
   cmd_mgr->bind_cmd("list-discovery", &app::command_handler_list_discovery, this)
       ->set_help_msg("list-discovery [start:0] [end]         list all discovery node.");
diff --git a/src/atframe/connectors/atapp_connector_atbus.cpp b/src/atframe/connectors/atapp_connector_atbus.cpp
index 25b1353..2c9f5d7 100644
--- a/src/atframe/connectors/atapp_connector_atbus.cpp
+++ b/src/atframe/connectors/atapp_connector_atbus.cpp
@@ -15,7 +15,7 @@
 
 #include <atframe/atapp.h>
 #include <atframe/atapp_common_types.h>
-#include <atframe/modules/etcd_module.h>
+#include <atframe/modules/service_discovery_module.h>
 
 LIBATAPP_MACRO_NAMESPACE_BEGIN
 
@@ -132,8 +132,8 @@ LIBATAPP_MACRO_API void atapp_connector_atbus::reload() noexcept {
     }
 
     // etcd update topology data to notify other nodes
-    if (get_owner()->get_etcd_module()) {
-      get_owner()->get_etcd_module()->set_maybe_update_keepalive_topology_value();
+    if (get_owner()->get_service_discovery_module()) {
+      get_owner()->get_service_discovery_module()->set_maybe_update_keepalive_topology_value();
     }
   }
 
diff --git a/src/atframe/etcdcli/etcd_discovery.cpp b/src/atframe/etcdcli/etcd_discovery.cpp
index c7bb531..0d38059 100644
--- a/src/atframe/etcdcli/etcd_discovery.cpp
+++ b/src/atframe/etcdcli/etcd_discovery.cpp
@@ -256,7 +256,7 @@ static bool node_equal(const etcd_discovery_node::ptr_t &l, const etcd_discovery
 
 }  // namespace
 
-LIBATAPP_MACRO_API etcd_discovery_node::etcd_discovery_node() : name_hash_(0, 0), ingress_index_(0) {
+LIBATAPP_MACRO_API etcd_discovery_node::etcd_discovery_node() : context_ptr_(0), name_hash_(0, 0), ingress_index_(0) {
   private_data_ptr_ = nullptr;
   private_data_u64_ = 0;
   private_data_uptr_ = 0;
@@ -269,17 +269,19 @@ LIBATAPP_MACRO_API etcd_discovery_node::~etcd_discovery_node() {
 }
 
 LIBATAPP_MACRO_API void etcd_discovery_node::copy_from(const atapp::protocol::atapp_discovery &input,
-                                                       const node_version &version) {
+                                                       const node_version &version, uintptr_t context_ptr) {
   node_info_.CopyFrom(input);
 
   name_hash_ = consistent_hash_calc(
       gsl::span<const unsigned char>{reinterpret_cast<const unsigned char *>(input.name().data()), input.name().size()},
       LIBATAPP_MACRO_HASH_MAGIC_NUMBER);
 
+  context_ptr_ = context_ptr;
+
   node_version_ = version;
 }
 
-LIBATAPP_MACRO_API void etcd_discovery_node::update_version(const node_version &version, bool upgrade) {
+LIBATAPP_MACRO_API void etcd_discovery_node::update_version(const node_version &version, bool upgrade, uintptr_t context_ptr) {
   if (upgrade) {
     if (version.create_revision > node_version_.create_revision) {
       node_version_.create_revision = version.create_revision;
@@ -297,6 +299,7 @@ LIBATAPP_MACRO_API void etcd_discovery_node::update_version(const node_version &
   } else {
     node_version_ = version;
   }
+  context_ptr_ = context_ptr;
 }
 
 LIBATAPP_MACRO_API void etcd_discovery_node::copy_to(atapp::protocol::atapp_discovery &output) const {
diff --git a/src/atframe/modules/etcd_module.cpp b/src/atframe/modules/etcd_module.cpp
index dbaf1b9..8c6b876 100644
--- a/src/atframe/modules/etcd_module.cpp
+++ b/src/atframe/modules/etcd_module.cpp
@@ -40,9 +40,6 @@
 #endif
 
 #define ETCD_MODULE_STARTUP_RETRY_TIMES 5
-#define ETCD_MODULE_BY_ID_DIR "by_id"
-#define ETCD_MODULE_BY_NAME_DIR "by_name"
-#define ETCD_MODULE_TOPOLOGY_DIR "topology"
 
 LIBATAPP_MACRO_NAMESPACE_BEGIN
 namespace {
@@ -80,235 +77,69 @@ static void init_timer_closed_callback(uv_handle_t *handle) {
   uv_stop(handle->loop);
 }
 
-static bool atapp_discovery_equal(const atapp::protocol::atapp_area &l, const atapp::protocol::atapp_area &r) {
-  if (l.zone_id() != r.zone_id()) {
-    return false;
-  }
-  if (l.region().size() != r.region().size()) {
-    return false;
-  }
-  if (l.district().size() != r.district().size()) {
-    return false;
-  }
-  if (l.region() != r.region()) {
-    return false;
-  }
-  if (l.district() != r.district()) {
-    return false;
-  }
+}  // namespace
 
-  return true;
+LIBATAPP_MACRO_API etcd_module::etcd_module()
+    : enable_(false),
+      atapp_(nullptr),
+      tick_interval_(std::chrono::duration_cast<std::chrono::system_clock::duration>(std::chrono::milliseconds(128))) {
+  tick_next_timepoint_ = app::get_sys_now();
 }
 
-static bool atapp_topology_equal(const atapp::protocol::atapp_topology_info &l,
-                                 const atapp::protocol::atapp_topology_info &r) {
-  if (l.id() != r.id()) {
-    return false;
-  }
-  if (l.upstream_id() != r.upstream_id()) {
-    return false;
-  }
-  if (l.name() != r.name()) {
-    return false;
-  }
+LIBATAPP_MACRO_API etcd_module::~etcd_module() { reset(); }
 
-  if (l.data().label().size() != r.data().label().size()) {
-    return false;
+LIBATAPP_MACRO_API int etcd_module::init(atframework::atapp::app &app, const atapp::protocol::atapp_etcd &conf,
+                                         const atapp::protocol::atapp_log *ATFW_UTIL_MACRO_NULLABLE log_conf) {
+  atapp_ = &app;
+  load_cluster_conf(conf, log_conf);
+  if (cluster_.get_conf_hosts().empty()) {
+    FWLOGINFO("cluster is disabled");
   }
-
-  for (const auto &kv : l.data().label()) {
-    auto it = r.data().label().find(kv.first);
-    if (it == r.data().label().end()) {
-      return false;
-    }
-    if (it->second != kv.second) {
-      return false;
-    }
+  if (is_etcd_enabled()) {
+    cluster_.init(atapp_->get_shared_curl_multi_context());
   }
-
-  return true;
+  return 0;
 }
 
-static bool topology_update_version(etcd_module::topology_storage_t &storage, const etcd_data_version &new_version,
-                                    bool upgrade) {
-  bool ret = false;
-  if (upgrade) {
-    if (new_version.create_revision > storage.version.create_revision) {
-      storage.version.create_revision = new_version.create_revision;
-      storage.version.version = new_version.version;
-      ret = true;
-    }
-
-    if (new_version.modify_revision > storage.version.modify_revision) {
-      storage.version.modify_revision = new_version.modify_revision;
-      storage.version.version = new_version.version;
-      ret = true;
-    }
-
-    if (new_version.version > storage.version.version) {
-      storage.version.version = new_version.version;
-      ret = true;
-    }
-  } else {
-    storage.version = new_version;
-    ret = true;
+LIBATAPP_MACRO_API int etcd_module::reload(const atapp::protocol::atapp_etcd &conf,
+                                           const atapp::protocol::atapp_log *ATFW_UTIL_MACRO_NULLABLE log_conf) {
+  if (atapp_ == nullptr) {
+    return 0;
   }
-
-  return ret;
-}
-}  // namespace
-
-struct ATFW_UTIL_SYMBOL_LOCAL etcd_module::topology_watcher_callback_list_wrapper_t {
-  etcd_module *mod;
-  std::list<topology_watcher_list_callback_t> *callbacks;
-  int64_t snapshot_index;
-  bool has_insert_snapshot_index;
-
-  topology_watcher_callback_list_wrapper_t(etcd_module &m, int64_t index);
-  topology_watcher_callback_list_wrapper_t(etcd_module &m, std::list<topology_watcher_list_callback_t> &cbks,
-                                           int64_t index);
-  ~topology_watcher_callback_list_wrapper_t();
-  void operator()(const ::atframework::atapp::etcd_response_header &header,
-                  const ::atframework::atapp::etcd_watcher::response_t &body);
-};
-
-struct ATFW_UTIL_SYMBOL_LOCAL etcd_module::discovery_watcher_callback_list_wrapper_t {
-  etcd_module *mod;
-  std::list<discovery_watcher_list_callback_t> *callbacks;
-  int64_t snapshot_index;
-  bool has_insert_snapshot_index;
-
-  discovery_watcher_callback_list_wrapper_t(etcd_module &m, int64_t index);
-  discovery_watcher_callback_list_wrapper_t(etcd_module &m, std::list<discovery_watcher_list_callback_t> &cbks,
-                                            int64_t index);
-  ~discovery_watcher_callback_list_wrapper_t();
-  void operator()(const ::atframework::atapp::etcd_response_header &header,
-                  const ::atframework::atapp::etcd_watcher::response_t &body);
-};
-
-struct ATFW_UTIL_SYMBOL_LOCAL etcd_module::watcher_internal_access_t {
-  static void cleanup_old_nodes(etcd_module &mod, etcd_discovery_set::node_by_name_type &old_names,
-                                etcd_discovery_set::node_by_id_type &old_ids);
-  static void cleanup_old_topology_peers(etcd_module &mod, std::unordered_map<uint64_t, topology_storage_t> &old_ids);
-};
-
-LIBATAPP_MACRO_API etcd_module::etcd_module()
-    : etcd_ctx_enabled_(false),
-      maybe_update_internal_keepalive_topology_value_(true),
-      maybe_update_internal_keepalive_discovery_value_(true),
-      maybe_update_internal_keepalive_discovery_area_(false),
-      maybe_update_internal_keepalive_discovery_metadata_(false),
-      tick_interval_(std::chrono::duration_cast<std::chrono::system_clock::duration>(std::chrono::milliseconds(128))),
-      last_etcd_event_topology_header_{},
-      last_etcd_event_discovery_header_{},
-      discovery_watcher_snapshot_index_allocator_(0),
-      topology_watcher_snapshot_index_allocator_(0) {
-  tick_next_timepoint_ = app::get_sys_now();
-
-  last_etcd_event_topology_header_.cluster_id = 0;
-  last_etcd_event_topology_header_.member_id = 0;
-  last_etcd_event_topology_header_.raft_term = 0;
-  last_etcd_event_topology_header_.revision = 0;
-
-  last_etcd_event_discovery_header_.cluster_id = 0;
-  last_etcd_event_discovery_header_.member_id = 0;
-  last_etcd_event_discovery_header_.raft_term = 0;
-  last_etcd_event_discovery_header_.revision = 0;
+  if (is_etcd_enabled()) {
+    load_cluster_conf(conf, log_conf);
+  }
+  return 0;
 }
 
-LIBATAPP_MACRO_API etcd_module::~etcd_module() { reset(); }
-
 LIBATAPP_MACRO_API void etcd_module::reset() {
   conf_path_cache_.clear();
-  custom_data_.clear();
+  conf_cache_.Clear();
   if (cleanup_request_) {
     cleanup_request_->set_priv_data(nullptr);
     cleanup_request_->set_on_complete(nullptr);
     cleanup_request_->stop();
     cleanup_request_.reset();
   }
-
-  etcd_ctx_.reset();
-
-  if (curl_multi_) {
-    atfw::util::network::http_request::destroy_curl_multi(curl_multi_);
-  }
+  cluster_.reset();
 }
 
-// NOLINTNEXTLINE(readability-function-cognitive-complexity)
-LIBATAPP_MACRO_API int etcd_module::init() {
-  // init curl
-  int res = curl_global_init(CURL_GLOBAL_ALL);
-  if (res) {
-    LIBATAPP_MACRO_ETCD_CLUSTER_LOG_ERROR(etcd_ctx_, "init cURL failed, errcode: {}", res);
-    return -1;
-  }
-
-  atfw::util::network::http_request::curl_share_options share_options;
-  atfw::util::network::http_request::curl_multi_options multi_options;
-  multi_options.ev_loop = get_app()->get_bus_node()->get_evloop();
-  // Share DNS cache, connection, TLS sessions and etc.
-  atfw::util::network::http_request::create_curl_share(share_options, multi_options.share_context);
-  atfw::util::network::http_request::create_curl_multi(get_app()->get_bus_node()->get_evloop(), curl_multi_);
-  if (!curl_multi_) {
-    LIBATAPP_MACRO_ETCD_CLUSTER_LOG_ERROR(etcd_ctx_, "create curl multi instance failed.");
-    return -1;
-  }
-
-  if (!etcd_ctx_enabled_) {
-    LIBATAPP_MACRO_ETCD_CLUSTER_LOG_INFO(etcd_ctx_, "etcd disabled, start single mode");
-    return res;
-  }
-
-  if (etcd_ctx_.get_conf_hosts().empty()) {
-    LIBATAPP_MACRO_ETCD_CLUSTER_LOG_INFO(etcd_ctx_, "etcd host not found, start single mode");
-    return res;
-  }
-
-  etcd_ctx_.init(curl_multi_);
-
-  // generate keepalives
-  res = init_keepalives();
-  if (res < 0) {
-    return res;
-  }
-  // generate watchers data
-  res = init_watchers();
-  if (res < 0) {
-    return res;
-  }
-
-  // Setup for first, we must check if all resource available.
-  const std::list<etcd_keepalive::ptr_t> *keepalive_actors[] = {&internal_discovery_keepalive_actors_,
-                                                                &internal_topology_keepalive_actors_};
-  // 初始化失败则回收资源
-  if (!check_keepalive_actor_start_success(get_app(), gsl::make_span(keepalive_actors))) {
-    stop();
-    reset();
-    return -1;
+LIBATAPP_MACRO_API bool etcd_module::check_keepalive_actor_start_success(
+    gsl::span<const std::list<etcd_keepalive::ptr_t> *> keepalive_actors) {
+  if (atapp_ == nullptr || !is_etcd_enabled()) {
+    return false;
   }
 
-  return res;
-}
-
-bool etcd_module::check_keepalive_actor_start_success(
-    atframework::atapp::app *app, gsl::span<const std::list<etcd_keepalive::ptr_t> *> keepalive_actors) {
   // setup timer for timeout
   uv_timer_t tick_timer;
   init_timer_data_type tick_timer_data;
-  uv_timer_init(app->get_bus_node()->get_evloop(), &tick_timer);
-  auto etcd_module = app->get_etcd_module();
-  if (etcd_module == nullptr) {
-    FWLOGERROR("etcd_module is null, can not check keepalive actors.");
-    return false;
-  }
-  auto &etcd_ctx = etcd_module->get_raw_etcd_ctx();
+  uv_timer_init(atapp_->get_bus_node()->get_evloop(), &tick_timer);
 
-  tick_timer_data.cluster = &etcd_ctx;
+  tick_timer_data.cluster = &cluster_;
   tick_timer_data.timeout = std::chrono::system_clock::now();
-  tick_timer_data.timeout += std::chrono::seconds(etcd_module->get_configure().init().timeout().seconds());
+  tick_timer_data.timeout += std::chrono::seconds(conf_cache_.init().timeout().seconds());
   tick_timer_data.timeout += std::chrono::duration_cast<std::chrono::system_clock::duration>(
-      std::chrono::nanoseconds(etcd_module->get_configure().init().timeout().nanos()));
+      std::chrono::nanoseconds(conf_cache_.init().timeout().nanos()));
   tick_timer.data = &tick_timer_data;
 
   uv_timer_start(&tick_timer, init_timer_tick_callback, 128, 128);
@@ -323,9 +154,9 @@ bool etcd_module::check_keepalive_actor_start_success(
     }
   }
 
-  while (false == is_failed && std::chrono::system_clock::now() <= tick_timer_data.timeout && nullptr != app) {
+  while (false == is_failed && std::chrono::system_clock::now() <= tick_timer_data.timeout) {
     atfw::util::time::time_utility::update();
-    etcd_ctx.tick();
+    cluster_.tick();
     ++ticks;
 
     size_t run_count = 0;
@@ -338,7 +169,7 @@ bool etcd_module::check_keepalive_actor_start_success(
            iter != keepalive_actor_list->end(); ++iter) {
         if ((*iter)->is_check_run()) {
           if (!(*iter)->is_check_passed()) {
-            LIBATAPP_MACRO_ETCD_CLUSTER_LOG_ERROR(etcd_ctx, "etcd_keepalive lock {} failed.", (*iter)->get_path());
+            LIBATAPP_MACRO_ETCD_CLUSTER_LOG_ERROR(cluster_, "etcd_keepalive lock {} failed.", (*iter)->get_path());
             is_failed = true;
           }
 
@@ -354,7 +185,7 @@ bool etcd_module::check_keepalive_actor_start_success(
       break;
     }
 
-    uv_run(app->get_bus_node()->get_evloop(), UV_RUN_ONCE);
+    uv_run(atapp_->get_bus_node()->get_evloop(), UV_RUN_ONCE);
 
     // 任意重试次数过多则失败退出
     for (const auto *keepalive_actor_list : keepalive_actors) {
@@ -364,12 +195,12 @@ bool etcd_module::check_keepalive_actor_start_success(
       for (std::list<etcd_keepalive::ptr_t>::const_iterator iter = keepalive_actor_list->begin();
            iter != keepalive_actor_list->end(); ++iter) {
         if ((*iter)->get_check_times() >= ETCD_MODULE_STARTUP_RETRY_TIMES ||
-            etcd_ctx.get_stats().continue_error_requests > ETCD_MODULE_STARTUP_RETRY_TIMES) {
+            cluster_.get_stats().continue_error_requests > ETCD_MODULE_STARTUP_RETRY_TIMES) {
           size_t retry_times = (*iter)->get_check_times();
-          if (etcd_ctx.get_stats().continue_error_requests > retry_times) {
-            retry_times = etcd_ctx.get_stats().continue_error_requests;
+          if (cluster_.get_stats().continue_error_requests > retry_times) {
+            retry_times = cluster_.get_stats().continue_error_requests;
           }
-          LIBATAPP_MACRO_ETCD_CLUSTER_LOG_ERROR(etcd_ctx,
+          LIBATAPP_MACRO_ETCD_CLUSTER_LOG_ERROR(cluster_,
                                                 "etcd_keepalive request {} for {} times (with {} ticks) failed.",
                                                 (*iter)->get_path(), retry_times, ticks);
           is_failed = true;
@@ -392,17 +223,17 @@ bool etcd_module::check_keepalive_actor_start_success(
       for (std::list<etcd_keepalive::ptr_t>::const_iterator iter = keepalive_actor_list->begin();
            iter != keepalive_actor_list->end(); ++iter) {
         size_t retry_times = (*iter)->get_check_times();
-        if (etcd_ctx.get_stats().continue_error_requests > retry_times) {
-          retry_times = etcd_ctx.get_stats().continue_error_requests;
+        if (cluster_.get_stats().continue_error_requests > retry_times) {
+          retry_times = cluster_.get_stats().continue_error_requests;
         }
         if ((*iter)->is_check_passed()) {
           LIBATAPP_MACRO_ETCD_CLUSTER_LOG_WARNING(
-              etcd_ctx,
+              cluster_,
               "etcd_keepalive request {} timeout, retry {} times (with {} ticks), check passed, has data: {}.",
               (*iter)->get_path(), retry_times, ticks, (*iter)->has_data() ? "true" : "false");
         } else {
           LIBATAPP_MACRO_ETCD_CLUSTER_LOG_ERROR(
-              etcd_ctx,
+              cluster_,
               "etcd_keepalive request {} timeout, retry {} times (with {} ticks), check unpassed, has data: {}.",
               (*iter)->get_path(), retry_times, ticks, (*iter)->has_data() ? "true" : "false");
         }
@@ -414,159 +245,75 @@ bool etcd_module::check_keepalive_actor_start_success(
   uv_timer_stop(&tick_timer);
   uv_close(reinterpret_cast<uv_handle_t *>(&tick_timer), init_timer_closed_callback);
   while (tick_timer.data != nullptr) {
-    uv_run(app->get_bus_node()->get_evloop(), UV_RUN_ONCE);
+    uv_run(atapp_->get_bus_node()->get_evloop(), UV_RUN_ONCE);
   }
 
   return !is_failed;
 }
 
-void etcd_module::update_keepalive_topology_value() {
-  if (!maybe_update_internal_keepalive_topology_value_ || nullptr == get_app()) {
-    return;
-  }
-  maybe_update_internal_keepalive_topology_value_ = false;
-
-  atapp_topology_info_ptr_t topology_ptr = atfw::util::memory::make_strong_rc<atapp::protocol::atapp_topology_info>();
-  get_app()->pack(*topology_ptr);
-
-  if (last_submmited_topology_data_ && atapp_topology_equal(*topology_ptr, *last_submmited_topology_data_)) {
-    return;
-  }
-  last_submmited_topology_data_ = topology_ptr;
-
-  std::string new_value;
-  pack(*topology_ptr, new_value);
-
-  if (new_value != internal_keepalive_topology_value_) {
-    internal_keepalive_topology_value_.swap(new_value);
-
-    for (std::list<etcd_keepalive::ptr_t>::iterator iter = internal_topology_keepalive_actors_.begin();
-         iter != internal_topology_keepalive_actors_.end(); ++iter) {
-      if (*iter) {
-        (*iter)->set_value(internal_keepalive_topology_value_);
-      }
-    }
-  }
-}
-
-void etcd_module::update_keepalive_discovery_value() {
-  if (!(maybe_update_internal_keepalive_discovery_value_ || maybe_update_internal_keepalive_discovery_area_ ||
-        maybe_update_internal_keepalive_discovery_metadata_) ||
-      nullptr == get_app()) {
-    return;
+LIBATAPP_MACRO_API int etcd_module::tick() {
+  if (atapp_ == nullptr) {
+    return 0;
   }
 
-  std::string new_value;
-  node_info_t ni;
-  get_app()->pack(ni.node_discovery);
-
-  bool has_changed = maybe_update_internal_keepalive_discovery_value_;
-  maybe_update_internal_keepalive_discovery_value_ = false;
-  if (maybe_update_internal_keepalive_discovery_area_) {
-    if (!atapp_discovery_equal(ni.node_discovery.area(), last_submmited_discovery_data_area_)) {
-      has_changed = true;
-      last_submmited_discovery_data_area_ = ni.node_discovery.area();
-    }
-  }
-  maybe_update_internal_keepalive_discovery_area_ = false;
-  if (maybe_update_internal_keepalive_discovery_metadata_) {
-    if (!etcd_discovery_set::metadata_equal_type()(ni.node_discovery.metadata(),
-                                                   last_submmited_discovery_data_metadata_)) {
-      has_changed = true;
-      last_submmited_discovery_data_metadata_ = ni.node_discovery.metadata();
-    }
+  // Slow down the tick interval of etcd module, it require http request which is very slow compared to atbus
+  if (tick_next_timepoint_ >= atapp_->get_last_tick_time()) {
+    return 0;
   }
-  maybe_update_internal_keepalive_discovery_metadata_ = false;
+  tick_next_timepoint_ = atapp_->get_last_tick_time() + tick_interval_;
 
-  if (!has_changed) {
-    return;
+  if (!is_etcd_enabled()) {
+    return 0;
   }
 
-  pack(ni, new_value);
-  if (new_value != internal_keepalive_discovery_value_) {
-    internal_keepalive_discovery_value_.swap(new_value);
-
-    for (std::list<etcd_keepalive::ptr_t>::iterator iter = internal_discovery_keepalive_actors_.begin();
-         iter != internal_discovery_keepalive_actors_.end(); ++iter) {
-      if (*iter) {
-        (*iter)->set_value(internal_keepalive_discovery_value_);
-      }
-    }
-  }
+  return cluster_.tick();
 }
 
-int etcd_module::init_keepalives() {
-  // 先刷新topology数据，后刷新discovery数据，以保证策略路由变化时已获取到最新的topology信息
-  update_keepalive_topology_value();
-  update_keepalive_discovery_value();
-
-  // topology
-  {
-    atapp::etcd_keepalive::ptr_t actor = add_keepalive_actor(internal_keepalive_topology_value_, get_topology_path());
-    if (!actor) {
-      LIBATAPP_MACRO_ETCD_CLUSTER_LOG_ERROR(etcd_ctx_, "create etcd_keepalive for topology index failed.");
-      return -1;
-    }
-
-    internal_topology_keepalive_actors_.push_back(actor);
-    LIBATAPP_MACRO_ETCD_CLUSTER_LOG_INFO(etcd_ctx_, "create etcd_keepalive {} for topology index {} success",
-                                         reinterpret_cast<const void *>(actor.get()), get_topology_path());
+LIBATAPP_MACRO_API int etcd_module::stop() {
+  if (atapp_ == nullptr) {
+    return 0;
   }
 
-  // by_id
-  {
-    atapp::etcd_keepalive::ptr_t actor =
-        add_keepalive_actor(internal_keepalive_discovery_value_, get_discovery_by_id_path());
-    if (!actor) {
-      LIBATAPP_MACRO_ETCD_CLUSTER_LOG_ERROR(etcd_ctx_, "create etcd_keepalive for by_id index failed.");
-      return -1;
+  if (!cleanup_request_ && !cluster_.check_flag(etcd_cluster::flag_t::kClosing)) {
+    bool revoke_lease = true;
+    if (atapp_->is_current_upgrade_mode()) {
+      revoke_lease = false;
     }
 
-    internal_discovery_keepalive_actors_.push_back(actor);
-    LIBATAPP_MACRO_ETCD_CLUSTER_LOG_INFO(etcd_ctx_, "create etcd_keepalive {} for by_id index {} success",
-                                         reinterpret_cast<const void *>(actor.get()), get_discovery_by_id_path());
-  }
+    cleanup_request_ = cluster_.close(false, revoke_lease);
 
-  // by name
-  {
-    atapp::etcd_keepalive::ptr_t actor =
-        add_keepalive_actor(internal_keepalive_discovery_value_, get_discovery_by_name_path());
-    if (!actor) {
-      LIBATAPP_MACRO_ETCD_CLUSTER_LOG_ERROR(etcd_ctx_, "create etcd_keepalive for by_name index failed.");
-      return -1;
+    if (cleanup_request_ && cleanup_request_->is_running()) {
+      cleanup_request_->set_priv_data(this);
+      cleanup_request_->set_on_complete(http_callback_on_etcd_closed);
     }
-
-    internal_discovery_keepalive_actors_.push_back(actor);
-    LIBATAPP_MACRO_ETCD_CLUSTER_LOG_INFO(etcd_ctx_, "create etcd_keepalive {} for by_name index {} success",
-                                         reinterpret_cast<const void *>(actor.get()), get_discovery_by_name_path());
   }
 
-  return 0;
-}
-
-int etcd_module::init_watchers() {
-  // setup internal discovery watchers
-  add_discovery_watcher_by_name(nullptr);
-  add_discovery_watcher_by_id(nullptr);
-
-  // setup internal topology watchers
-  add_topology_watcher(nullptr);
+  if (cleanup_request_ && cleanup_request_->is_running()) {
+    return 1;
+  }
 
+  // recycle all resources
+  reset();
   return 0;
 }
 
-LIBATAPP_MACRO_API int etcd_module::reload() {
+void etcd_module::load_cluster_conf(const atapp::protocol::atapp_etcd &conf,
+                                    const atapp::protocol::atapp_log *ATFW_UTIL_MACRO_NULLABLE log_conf) {
   // load configure
-  conf_path_cache_.clear();
-  const atapp::protocol::atapp_etcd &conf = get_configure();
+  conf_cache_ = conf;
+  enable_ = conf.enable();
 
   // load logger
   atfw::util::log::log_wrapper::ptr_t logger;
   atfw::util::log::log_level startup_level = atfw::util::log::log_level::kDisabled;
   do {
     atapp::protocol::atapp_log etcd_log_conf;
-    get_app()->parse_log_configures_into(etcd_log_conf, std::vector<gsl::string_view>{"atapp", "etcd", "log"},
-                                         "ATAPP_ETCD_LOG");
+    if (log_conf != nullptr) {
+      etcd_log_conf = *log_conf;
+    } else {
+      atapp_->parse_log_configures_into(etcd_log_conf, std::vector<gsl::string_view>{"atapp", "etcd", "log"},
+                                        "ATAPP_ETCD_LOG");
+    }
     if (etcd_log_conf.category_size() <= 0) {
       break;
     }
@@ -583,9 +330,9 @@ LIBATAPP_MACRO_API int etcd_module::reload() {
       break;
     }
     logger->init(atfw::util::log::log_formatter::get_level_by_name(etcd_log_conf.level()));
-    get_app()->setup_logger(*logger, etcd_log_conf.level(), etcd_log_conf.category(0));
+    atapp_->setup_logger(*logger, etcd_log_conf.level(), etcd_log_conf.category(0));
   } while (false);
-  etcd_ctx_.set_logger(logger, startup_level);
+  cluster_.set_logger(logger, startup_level);
 
   // etcd context configure
   {
@@ -595,64 +342,64 @@ LIBATAPP_MACRO_API int etcd_module::reload() {
       conf_hosts.push_back(conf.hosts(i));
     }
     if (!conf_hosts.empty()) {
-      etcd_ctx_.set_conf_hosts(conf_hosts);
+      cluster_.set_conf_hosts(conf_hosts);
     }
   }
 
-  etcd_ctx_.set_conf_authorization(conf.authorization());
-  etcd_ctx_.set_conf_http_request_timeout(
+  cluster_.set_conf_authorization(conf.authorization());
+  cluster_.set_conf_http_request_timeout(
       protobuf_to_chrono_convert_duration_with_default<std::chrono::system_clock::duration>(
           conf.request().timeout(), std::chrono::milliseconds(10000)));
-  etcd_ctx_.set_conf_http_initialization_timeout(
+  cluster_.set_conf_http_initialization_timeout(
       protobuf_to_chrono_convert_duration_with_default<std::chrono::system_clock::duration>(
           conf.request().initialization_timeout(), std::chrono::milliseconds(3000)));
-  etcd_ctx_.set_conf_http_connect_timeout(
+  cluster_.set_conf_http_connect_timeout(
       protobuf_to_chrono_convert_duration_with_default<std::chrono::system_clock::duration>(
           conf.request().connect_timeout(), std::chrono::milliseconds(0)));
-  etcd_ctx_.set_conf_dns_cache_timeout(
+  cluster_.set_conf_dns_cache_timeout(
       protobuf_to_chrono_convert_duration_with_default<std::chrono::system_clock::duration>(
           conf.request().dns_cache_timeout(), std::chrono::milliseconds(0)));
-  etcd_ctx_.set_conf_dns_servers(conf.request().dns_servers());
-  etcd_ctx_.set_conf_etcd_members_auto_update_hosts(conf.cluster().auto_update());
-  etcd_ctx_.set_conf_etcd_members_update_interval(
+  cluster_.set_conf_dns_servers(conf.request().dns_servers());
+  cluster_.set_conf_etcd_members_auto_update_hosts(conf.cluster().auto_update());
+  cluster_.set_conf_etcd_members_update_interval(
       protobuf_to_chrono_convert_duration_with_default<std::chrono::system_clock::duration>(
           conf.cluster().update_interval(), std::chrono::milliseconds(300000)));
-  etcd_ctx_.set_conf_etcd_members_retry_interval(
+  cluster_.set_conf_etcd_members_retry_interval(
       protobuf_to_chrono_convert_duration_with_default<std::chrono::system_clock::duration>(
           conf.cluster().retry_interval(), std::chrono::milliseconds(60000)));
 
-  etcd_ctx_.set_conf_keepalive_timeout(
+  cluster_.set_conf_keepalive_timeout(
       protobuf_to_chrono_convert_duration_with_default<std::chrono::system_clock::duration>(
           conf.keepalive().timeout(), std::chrono::milliseconds(16000)));
-  etcd_ctx_.set_conf_keepalive_interval(
+  cluster_.set_conf_keepalive_interval(
       protobuf_to_chrono_convert_duration_with_default<std::chrono::system_clock::duration>(
           conf.keepalive().ttl(), std::chrono::milliseconds(5000)));
-  etcd_ctx_.set_conf_keepalive_retry_interval(
+  cluster_.set_conf_keepalive_retry_interval(
       protobuf_to_chrono_convert_duration_with_default<std::chrono::system_clock::duration>(
           conf.keepalive().retry_interval(), std::chrono::milliseconds(3000)));
 
   // HTTP
   if (!conf.http().user_agent().empty()) {
-    etcd_ctx_.set_conf_user_agent(conf.http().user_agent());
+    cluster_.set_conf_user_agent(conf.http().user_agent());
   }
   if (!conf.http().proxy().empty()) {
-    etcd_ctx_.set_conf_proxy(conf.http().proxy());
+    cluster_.set_conf_proxy(conf.http().proxy());
   }
   if (!conf.http().no_proxy().empty()) {
-    etcd_ctx_.set_conf_no_proxy(conf.http().no_proxy());
+    cluster_.set_conf_no_proxy(conf.http().no_proxy());
   }
   if (!conf.http().proxy_user_name().empty()) {
-    etcd_ctx_.set_conf_proxy_user_name(conf.http().proxy_user_name());
+    cluster_.set_conf_proxy_user_name(conf.http().proxy_user_name());
   }
   if (!conf.http().proxy_password().empty()) {
-    etcd_ctx_.set_conf_proxy_password(conf.http().proxy_password());
+    cluster_.set_conf_proxy_password(conf.http().proxy_password());
   }
 
-  etcd_ctx_.set_conf_http_debug_mode(conf.http().debug());
+  cluster_.set_conf_http_debug_mode(conf.http().debug());
 
   // SSL configure
-  etcd_ctx_.set_conf_ssl_enable_alpn(conf.ssl().enable_alpn());
-  etcd_ctx_.set_conf_ssl_verify_peer(conf.ssl().verify_peer());
+  cluster_.set_conf_ssl_enable_alpn(conf.ssl().enable_alpn());
+  cluster_.set_conf_ssl_verify_peer(conf.ssl().verify_peer());
   do {
     const std::string &ssl_version = conf.ssl().ssl_min_version();
     if (ssl_version.empty()) {
@@ -660,1179 +407,123 @@ LIBATAPP_MACRO_API int etcd_module::reload() {
     }
     if (0 == UTIL_STRFUNC_STRNCASE_CMP(ssl_version.c_str(), "TLSv1.3", 7) ||
         0 == UTIL_STRFUNC_STRNCASE_CMP(ssl_version.c_str(), "TLSv13", 6)) {
-      etcd_ctx_.set_conf_ssl_min_version(etcd_cluster::ssl_version_t::kTlsV13);
+      cluster_.set_conf_ssl_min_version(etcd_cluster::ssl_version_t::kTlsV13);
     } else if (0 == UTIL_STRFUNC_STRNCASE_CMP(ssl_version.c_str(), "TLSv1.2", 7) ||
                0 == UTIL_STRFUNC_STRNCASE_CMP(ssl_version.c_str(), "TLSv12", 6)) {
-      etcd_ctx_.set_conf_ssl_min_version(etcd_cluster::ssl_version_t::kTlsV12);
+      cluster_.set_conf_ssl_min_version(etcd_cluster::ssl_version_t::kTlsV12);
     } else if (0 == UTIL_STRFUNC_STRNCASE_CMP(ssl_version.c_str(), "TLSv1.1", 7) ||
                0 == UTIL_STRFUNC_STRNCASE_CMP(ssl_version.c_str(), "TLSv11", 6)) {
-      etcd_ctx_.set_conf_ssl_min_version(etcd_cluster::ssl_version_t::kTlsV11);
+      cluster_.set_conf_ssl_min_version(etcd_cluster::ssl_version_t::kTlsV11);
     } else if (0 == UTIL_STRFUNC_STRCASE_CMP(ssl_version.c_str(), "TLSv1")) {
-      etcd_ctx_.set_conf_ssl_min_version(etcd_cluster::ssl_version_t::kTlsV11);
+      cluster_.set_conf_ssl_min_version(etcd_cluster::ssl_version_t::kTlsV11);
     } else {
-      etcd_ctx_.set_conf_ssl_min_version(etcd_cluster::ssl_version_t::kDisabled);
+      cluster_.set_conf_ssl_min_version(etcd_cluster::ssl_version_t::kDisabled);
     }
   } while (false);
 
   if (!conf.ssl().ssl_client_cert().empty()) {
-    etcd_ctx_.set_conf_ssl_client_cert(conf.ssl().ssl_client_cert());
+    cluster_.set_conf_ssl_client_cert(conf.ssl().ssl_client_cert());
   }
 
   if (!conf.ssl().ssl_client_cert_type().empty()) {
-    etcd_ctx_.set_conf_ssl_client_cert_type(conf.ssl().ssl_client_cert_type());
+    cluster_.set_conf_ssl_client_cert_type(conf.ssl().ssl_client_cert_type());
   }
 
   if (!conf.ssl().ssl_client_key().empty()) {
-    etcd_ctx_.set_conf_ssl_client_key(conf.ssl().ssl_client_key());
+    cluster_.set_conf_ssl_client_key(conf.ssl().ssl_client_key());
   }
 
   if (!conf.ssl().ssl_client_key_type().empty()) {
-    etcd_ctx_.set_conf_ssl_client_key_type(conf.ssl().ssl_client_key_type());
+    cluster_.set_conf_ssl_client_key_type(conf.ssl().ssl_client_key_type());
   }
 
   if (!conf.ssl().ssl_client_key_passwd().empty()) {
-    etcd_ctx_.set_conf_ssl_client_key_passwd(conf.ssl().ssl_client_key_passwd());
+    cluster_.set_conf_ssl_client_key_passwd(conf.ssl().ssl_client_key_passwd());
   }
 
   if (!conf.ssl().ssl_ca_cert().empty()) {
-    etcd_ctx_.set_conf_ssl_ca_cert(conf.ssl().ssl_ca_cert());
+    cluster_.set_conf_ssl_ca_cert(conf.ssl().ssl_ca_cert());
   }
 
   if (!conf.ssl().ssl_proxy_cert().empty()) {
-    etcd_ctx_.set_conf_ssl_proxy_cert(conf.ssl().ssl_proxy_cert());
+    cluster_.set_conf_ssl_proxy_cert(conf.ssl().ssl_proxy_cert());
   }
 
   if (!conf.ssl().ssl_proxy_cert_type().empty()) {
-    etcd_ctx_.set_conf_ssl_proxy_cert_type(conf.ssl().ssl_proxy_cert_type());
+    cluster_.set_conf_ssl_proxy_cert_type(conf.ssl().ssl_proxy_cert_type());
   }
 
   if (!conf.ssl().ssl_proxy_key().empty()) {
-    etcd_ctx_.set_conf_ssl_proxy_key(conf.ssl().ssl_proxy_key());
+    cluster_.set_conf_ssl_proxy_key(conf.ssl().ssl_proxy_key());
   }
 
   if (!conf.ssl().ssl_proxy_key_type().empty()) {
-    etcd_ctx_.set_conf_ssl_proxy_key_type(conf.ssl().ssl_proxy_key_type());
+    cluster_.set_conf_ssl_proxy_key_type(conf.ssl().ssl_proxy_key_type());
   }
 
   if (!conf.ssl().ssl_proxy_key_passwd().empty()) {
-    etcd_ctx_.set_conf_ssl_proxy_key_passwd(conf.ssl().ssl_proxy_key_passwd());
+    cluster_.set_conf_ssl_proxy_key_passwd(conf.ssl().ssl_proxy_key_passwd());
   }
 
   if (!conf.ssl().ssl_proxy_ca_cert().empty()) {
-    etcd_ctx_.set_conf_ssl_proxy_ca_cert(conf.ssl().ssl_proxy_ca_cert());
+    cluster_.set_conf_ssl_proxy_ca_cert(conf.ssl().ssl_proxy_ca_cert());
   }
 
   if (!conf.ssl().ssl_cipher_list().empty()) {
-    etcd_ctx_.set_conf_ssl_cipher_list(conf.ssl().ssl_cipher_list());
+    cluster_.set_conf_ssl_cipher_list(conf.ssl().ssl_cipher_list());
   }
 
   if (!conf.ssl().ssl_cipher_list_tls13().empty()) {
-    etcd_ctx_.set_conf_ssl_cipher_list_tls13(conf.ssl().ssl_cipher_list_tls13());
+    cluster_.set_conf_ssl_cipher_list_tls13(conf.ssl().ssl_cipher_list_tls13());
   }
 
-  etcd_ctx_enabled_ = conf.enable();
   tick_interval_ = std::chrono::duration_cast<std::chrono::system_clock::duration>(
       std::chrono::seconds(conf.init().tick_interval().seconds()) +
       std::chrono::nanoseconds(conf.init().tick_interval().nanos()));
   if (tick_interval_ < std::chrono::duration_cast<std::chrono::system_clock::duration>(std::chrono::milliseconds(32))) {
     tick_interval_ = std::chrono::duration_cast<std::chrono::system_clock::duration>(std::chrono::milliseconds(128));
   }
-  return 0;
 }
 
-LIBATAPP_MACRO_API int etcd_module::stop() {
-  if (!cleanup_request_ && !etcd_ctx_.check_flag(etcd_cluster::flag_t::kClosing)) {
-    bool revoke_lease = true;
-    if (get_app() != nullptr && get_app()->is_current_upgrade_mode()) {
-      revoke_lease = false;
-    }
-
-    cleanup_request_ = etcd_ctx_.close(false, revoke_lease);
-
-    if (cleanup_request_ && cleanup_request_->is_running()) {
-      cleanup_request_->set_priv_data(this);
-      cleanup_request_->set_on_complete(http_callback_on_etcd_closed);
+LIBATAPP_MACRO_API std::string etcd_module::generate_etcd_path(const std::string &path) {
+  std::string gen_path = path;
+  if (!gen_path.empty()) {
+    size_t last_idx = gen_path.size() - 1;
+    if (gen_path[last_idx] != '/' && gen_path[last_idx] != '\\') {
+      gen_path += '/';
     }
-    reset_internal_watchers_and_keepalives();
-  }
-
-  if (cleanup_request_ && cleanup_request_->is_running()) {
-    return 1;
+  } else {
+    gen_path = std::string("/");
   }
-
-  // recycle all resources
-  reset();
-  return 0;
-}
-
-LIBATAPP_MACRO_API int etcd_module::timeout() {
-  reset();
-  return 0;
+  return gen_path;
 }
 
-LIBATAPP_MACRO_API const char *ATFW_UTIL_MACRO_NONNULL etcd_module::name() const { return "atapp: etcd module"; }
-
-LIBATAPP_MACRO_API int etcd_module::tick() {
-  atframework::atapp::app *owner = get_app();
-  if (nullptr == owner) {
-    return 0;
-  }
-
-  // Slow down the tick interval of etcd module, it require http request which is very slow compared to atbus
-  if (tick_next_timepoint_ >= owner->get_last_tick_time()) {
-    return 0;
-  }
-  tick_next_timepoint_ = owner->get_last_tick_time() + tick_interval_;
-
-  // single mode
-  if (etcd_ctx_.get_conf_hosts().empty() || !etcd_ctx_enabled_) {
-    // If it's initializing, is_available() will return false
-    if (!cleanup_request_ && etcd_ctx_.is_available()) {
-      bool revoke_lease = true;
-      if (owner->is_current_upgrade_mode()) {
-        revoke_lease = false;
-      }
-
-      cleanup_request_ = etcd_ctx_.close(false, revoke_lease);
-      reset_internal_watchers_and_keepalives();
-    }
-
+int etcd_module::http_callback_on_etcd_closed(atfw::util::network::http_request &req) {
+  etcd_module *self = reinterpret_cast<etcd_module *>(req.get_priv_data());
+  if (nullptr == self) {
+    FWLOGERROR("etcd_module get request shouldn't has request without private data");
     return 0;
   }
 
-  // previous closing not finished, wait for it
-  if (cleanup_request_ || owner->is_closing()) {
-    return etcd_ctx_.tick();
-  }
-
-  // first startup when reloaded
-  if (!curl_multi_) {
-    int res = init();
-    if (res < 0) {
-      LIBATAPP_MACRO_ETCD_CLUSTER_LOG_ERROR(etcd_ctx_, "initialize etcd failed, res: {}", res);
-      owner->stop();
-      return res;
-    }
-  } else if (etcd_ctx_.check_flag(etcd_cluster::flag_t::kClosing)) {  // Already stoped and restart etcd_ctx_
-    etcd_ctx_.init(curl_multi_);
-    // generate keepalives
-    int res = init_keepalives();
-    if (res < 0) {
-      LIBATAPP_MACRO_ETCD_CLUSTER_LOG_ERROR(etcd_ctx_, "reinitialize etcd keepalives failed, res: {}", res);
-    }
-    // generate watchers data
-    res = init_watchers();
-    if (res < 0) {
-      LIBATAPP_MACRO_ETCD_CLUSTER_LOG_ERROR(etcd_ctx_, "reinitialize etcd watchers failed, res: {}", res);
-    }
-  }
-
-  int ret = etcd_ctx_.tick();
-
-  if (maybe_update_internal_keepalive_topology_value_) {
-    update_keepalive_topology_value();
-  }
-
-  if ((maybe_update_internal_keepalive_discovery_value_ || maybe_update_internal_keepalive_discovery_area_ ||
-       maybe_update_internal_keepalive_discovery_metadata_) &&
-      etcd_ctx_.check_flag(etcd_cluster::flag_t::kRunning)) {
-    update_keepalive_discovery_value();
-  }
-
-  return ret;
-}
-
-LIBATAPP_MACRO_API const std::string &etcd_module::get_conf_custom_data() const { return custom_data_; }
-LIBATAPP_MACRO_API void etcd_module::set_conf_custom_data(const std::string &v) { custom_data_ = v; }
-
-LIBATAPP_MACRO_API bool etcd_module::is_etcd_enabled() const {
-  return etcd_ctx_enabled_ && !etcd_ctx_.get_conf_hosts().empty();
-}
-LIBATAPP_MACRO_API void etcd_module::enable_etcd() { etcd_ctx_enabled_ = true; }
-LIBATAPP_MACRO_API void etcd_module::disable_etcd() { etcd_ctx_enabled_ = false; }
-
-LIBATAPP_MACRO_API void etcd_module::set_maybe_update_keepalive_topology_value() {
-  maybe_update_internal_keepalive_topology_value_ = true;
-}
-
-LIBATAPP_MACRO_API void etcd_module::set_maybe_update_keepalive_discovery_value() {
-  maybe_update_internal_keepalive_discovery_value_ = true;
-}
-
-LIBATAPP_MACRO_API void etcd_module::set_maybe_update_keepalive_discovery_area() {
-  maybe_update_internal_keepalive_discovery_area_ = true;
-}
-
-LIBATAPP_MACRO_API void etcd_module::set_maybe_update_keepalive_discovery_metadata() {
-  maybe_update_internal_keepalive_discovery_metadata_ = true;
-}
-
-LIBATAPP_MACRO_API const atfw::util::network::http_request::curl_m_bind_ptr_t &
-etcd_module::get_shared_curl_multi_context() const {
-  return curl_multi_;
-}
-
-LIBATAPP_MACRO_API std::string etcd_module::get_discovery_by_id_path() const {
-  const atframework::atapp::app *owner = get_app();
-  if (nullptr == owner) {
-    return std::string();
-  }
-
-  return LOG_WRAPPER_FWAPI_FORMAT("{}{}/{}-{}", get_configure_path(), ETCD_MODULE_BY_ID_DIR, owner->get_app_name(),
-                                  owner->get_id());
-}
-
-LIBATAPP_MACRO_API std::string etcd_module::get_discovery_by_name_path() const {
-  const atframework::atapp::app *owner = get_app();
-  if (nullptr == owner) {
-    return std::string();
-  }
-
-  return LOG_WRAPPER_FWAPI_FORMAT("{}{}/{}-{}", get_configure_path(), ETCD_MODULE_BY_NAME_DIR, owner->get_app_name(),
-                                  owner->get_id());
-}
-
-LIBATAPP_MACRO_API std::string etcd_module::get_topology_path() const {
-  const atframework::atapp::app *owner = get_app();
-  if (nullptr == owner) {
-    return std::string();
-  }
-
-  return LOG_WRAPPER_FWAPI_FORMAT("{}{}/{}-{}", get_configure_path(), ETCD_MODULE_TOPOLOGY_DIR, owner->get_app_name(),
-                                  owner->get_id());
-}
-
-LIBATAPP_MACRO_API std::string etcd_module::get_discovery_by_id_watcher_path() const {
-  return LOG_WRAPPER_FWAPI_FORMAT("{}{}", get_configure_path(), ETCD_MODULE_BY_ID_DIR);
-}
-
-LIBATAPP_MACRO_API std::string etcd_module::get_discovery_by_name_watcher_path() const {
-  return LOG_WRAPPER_FWAPI_FORMAT("{}{}", get_configure_path(), ETCD_MODULE_BY_NAME_DIR);
-}
-
-LIBATAPP_MACRO_API std::string etcd_module::get_topology_watcher_path() const {
-  return LOG_WRAPPER_FWAPI_FORMAT("{}{}", get_configure_path(), ETCD_MODULE_TOPOLOGY_DIR);
-}
-
-LIBATAPP_MACRO_API int etcd_module::add_discovery_watcher_by_id(const discovery_watcher_list_callback_t &fn) {
-  std::lock_guard<std::recursive_mutex> lock_guard{discovery_watcher_callback_lock_};
-
-  if (!internal_discovery_watcher_by_id_) {
-    std::string watch_path = LOG_WRAPPER_FWAPI_FORMAT("{}{}", get_configure_path(), ETCD_MODULE_BY_ID_DIR);
-
-    internal_discovery_watcher_by_id_ = atapp::etcd_watcher::create(etcd_ctx_, watch_path, "+1");
-    if (!internal_discovery_watcher_by_id_) {
-      LIBATAPP_MACRO_ETCD_CLUSTER_LOG_ERROR(etcd_ctx_, "create etcd_watcher by_id failed.");
-      return EN_ATBUS_ERR_MALLOC;
-    }
-
-    internal_discovery_watcher_by_id_->set_conf_from_protobuf(get_configure().watcher());
-    etcd_ctx_.add_watcher(internal_discovery_watcher_by_id_);
-    LIBATAPP_MACRO_ETCD_CLUSTER_LOG_INFO(etcd_ctx_, "create etcd_watcher for by_id index {} success", watch_path);
-
-    internal_discovery_watcher_by_id_->set_evt_handle(discovery_watcher_callback_list_wrapper_t(
-        *this, discovery_watcher_by_id_callbacks_, ++discovery_watcher_snapshot_index_allocator_));
-  }
-
-  if (fn) {
-    discovery_watcher_by_id_callbacks_.push_back(fn);
-  }
-  return 0;
-}
-
-LIBATAPP_MACRO_API int etcd_module::add_discovery_watcher_by_name(const discovery_watcher_list_callback_t &fn) {
-  std::lock_guard<std::recursive_mutex> lock_guard{discovery_watcher_callback_lock_};
-  if (!internal_discovery_watcher_by_name_) {
-    // generate watch data
-    std::string watch_path = LOG_WRAPPER_FWAPI_FORMAT("{}{}", get_configure_path(), ETCD_MODULE_BY_NAME_DIR);
-
-    internal_discovery_watcher_by_name_ = atapp::etcd_watcher::create(etcd_ctx_, watch_path, "+1");
-    if (!internal_discovery_watcher_by_name_) {
-      LIBATAPP_MACRO_ETCD_CLUSTER_LOG_ERROR(etcd_ctx_, "create etcd_watcher by_name failed.");
-      return EN_ATBUS_ERR_MALLOC;
-    }
-
-    internal_discovery_watcher_by_name_->set_conf_from_protobuf(get_configure().watcher());
-    etcd_ctx_.add_watcher(internal_discovery_watcher_by_name_);
-    LIBATAPP_MACRO_ETCD_CLUSTER_LOG_INFO(etcd_ctx_, "create etcd_watcher for by_name index {} success", watch_path);
-
-    internal_discovery_watcher_by_name_->set_evt_handle(discovery_watcher_callback_list_wrapper_t(
-        *this, discovery_watcher_by_name_callbacks_, ++discovery_watcher_snapshot_index_allocator_));
-  }
-
-  if (fn) {
-    discovery_watcher_by_name_callbacks_.push_back(fn);
-  }
-  return 0;
-}
-
-LIBATAPP_MACRO_API int etcd_module::add_topology_watcher(const topology_watcher_list_callback_t &fn) {
-  std::lock_guard<std::recursive_mutex> lock_guard{topology_watcher_callback_lock_};
-  if (!internal_topology_watcher_) {
-    // generate watch data
-    std::string watch_path = LOG_WRAPPER_FWAPI_FORMAT("{}{}", get_configure_path(), ETCD_MODULE_TOPOLOGY_DIR);
-
-    internal_topology_watcher_ = atapp::etcd_watcher::create(etcd_ctx_, watch_path, "+1");
-    if (!internal_topology_watcher_) {
-      LIBATAPP_MACRO_ETCD_CLUSTER_LOG_ERROR(etcd_ctx_, "create etcd_watcher topology failed.");
-      return EN_ATBUS_ERR_MALLOC;
-    }
-
-    internal_topology_watcher_->set_conf_from_protobuf(get_configure().watcher());
-    etcd_ctx_.add_watcher(internal_topology_watcher_);
-    LIBATAPP_MACRO_ETCD_CLUSTER_LOG_INFO(etcd_ctx_, "create etcd_watcher for topology index {} success", watch_path);
-
-    internal_topology_watcher_->set_evt_handle(topology_watcher_callback_list_wrapper_t(
-        *this, topology_watcher_callbacks_, ++topology_watcher_snapshot_index_allocator_));
-  }
+  self->reset();
 
-  if (fn) {
-    topology_watcher_callbacks_.push_back(fn);
-  }
+  LIBATAPP_MACRO_ETCD_CLUSTER_LOG_DEBUG(self->cluster_, "Etcd revoke lease finished");
   return 0;
 }
 
-LIBATAPP_MACRO_API const ::atframework::atapp::etcd_cluster &etcd_module::get_raw_etcd_ctx() const { return etcd_ctx_; }
-LIBATAPP_MACRO_API ::atframework::atapp::etcd_cluster &etcd_module::get_raw_etcd_ctx() { return etcd_ctx_; }
-
-LIBATAPP_MACRO_API const ::atframework::atapp::etcd_response_header &etcd_module::get_last_etcd_event_topology_header()
-    const noexcept {
-  return last_etcd_event_topology_header_;
-}
+LIBATAPP_MACRO_API bool etcd_module::is_etcd_enabled() const { return !cluster_.get_conf_hosts().empty() && enable_; }
 
-LIBATAPP_MACRO_API const ::atframework::atapp::etcd_response_header &etcd_module::get_last_etcd_event_discovery_header()
-    const noexcept {
-  return last_etcd_event_discovery_header_;
-}
+LIBATAPP_MACRO_API atapp::etcd_cluster &etcd_module::get_etcd_cluster() { return cluster_; }
 
-LIBATAPP_MACRO_API const atapp::protocol::atapp_etcd &etcd_module::get_configure() const {
-  return get_app()->get_origin_configure().etcd();
-}
+LIBATAPP_MACRO_API const atapp::etcd_cluster &etcd_module::get_etcd_cluster() const { return cluster_; }
 
-LIBATAPP_MACRO_API const std::string &etcd_module::get_configure_path() const {
+LIBATAPP_MACRO_API const std::string &etcd_module::get_configure_path() {
   if (conf_path_cache_.empty()) {
-    etcd_module *self = const_cast<etcd_module *>(this);
-    self->conf_path_cache_ = generate_etcd_path(get_configure().path());
+    conf_path_cache_ = generate_etcd_path(conf_cache_.path());
   }
-
   return conf_path_cache_;
 }
 
-std::string etcd_module::generate_etcd_path(const std::string &path) {
-  std::string gen_path = path;
-  if (!gen_path.empty()) {
-    size_t last_idx = gen_path.size() - 1;
-    if (gen_path[last_idx] != '/' && gen_path[last_idx] != '\\') {
-      gen_path += '/';
-    }
-  } else {
-    gen_path = std::string("/");
-  }
-  return gen_path;
-}
-
-LIBATAPP_MACRO_API atapp::etcd_keepalive::ptr_t etcd_module::add_keepalive_actor(std::string &val,
-                                                                                 const std::string &node_path) {
-  atapp::etcd_keepalive::ptr_t ret;
-  if (nullptr == get_app()) {
-    return ret;
-  }
-
-  if (val.empty()) {
-    node_info_t ni;
-    get_app()->pack(ni.node_discovery);
-    pack(ni, val);
-  }
-
-  ret = atapp::etcd_keepalive::create(etcd_ctx_, node_path);
-  if (!ret) {
-    LIBATAPP_MACRO_ETCD_CLUSTER_LOG_ERROR(etcd_ctx_, "create etcd_keepalive failed.");
-    return ret;
-  }
-
-  ret->set_checker(val);
-  ret->set_value(val);
-
-  if (!etcd_ctx_.add_keepalive(ret)) {
-    ret.reset();
-  }
-
-  return ret;
-}
-
-LIBATAPP_MACRO_API bool etcd_module::remove_keepalive_actor(const atapp::etcd_keepalive::ptr_t &keepalive) {
-  if (!keepalive) {
-    return false;
-  }
-
-  std::list<etcd_keepalive::ptr_t> *keepalive_actors[] = {&internal_discovery_keepalive_actors_,
-                                                          &internal_topology_keepalive_actors_};
-
-  for (auto *keepalive_actor_list : keepalive_actors) {
-    std::list<etcd_keepalive::ptr_t>::iterator internal_iter =
-        std::find(keepalive_actor_list->begin(), keepalive_actor_list->end(), keepalive);
-    if (internal_iter != keepalive_actor_list->end()) {
-      keepalive_actor_list->erase(internal_iter);
-    }
-  }
-
-  return etcd_ctx_.remove_keepalive(keepalive);
-}
-
-LIBATAPP_MACRO_API etcd_module::node_event_callback_handle_t etcd_module::add_on_node_discovery_event(
-    const node_event_callback_t &fn) {
-  std::lock_guard<std::recursive_mutex> lock_guard{node_event_lock_};
-  if (!fn) {
-    return node_event_callbacks_.end();
-  }
-
-  return node_event_callbacks_.insert(node_event_callbacks_.end(), fn);
-}
-
-LIBATAPP_MACRO_API void etcd_module::remove_on_node_event(node_event_callback_handle_t &handle) {
-  std::lock_guard<std::recursive_mutex> lock_guard{node_event_lock_};
-  if (handle == node_event_callbacks_.end()) {
-    return;
-  }
-
-  node_event_callbacks_.erase(handle);
-  handle = node_event_callbacks_.end();
-}
-
-LIBATAPP_MACRO_API etcd_module::topology_info_event_callback_handle_t etcd_module::add_on_topology_info_event(
-    const topology_info_event_callback_t &fn) {
-  std::lock_guard<std::recursive_mutex> lock_guard{topology_info_event_lock_};
-  if (!fn) {
-    return topology_info_event_callbacks_.end();
-  }
-
-  return topology_info_event_callbacks_.insert(topology_info_event_callbacks_.end(), fn);
-}
-
-LIBATAPP_MACRO_API void etcd_module::remove_on_topology_info_event(topology_info_event_callback_handle_t &handle) {
-  std::lock_guard<std::recursive_mutex> lock_guard{topology_info_event_lock_};
-  if (handle == topology_info_event_callbacks_.end()) {
-    return;
-  }
-
-  topology_info_event_callbacks_.erase(handle);
-  handle = topology_info_event_callbacks_.end();
-}
-
-LIBATAPP_MACRO_API etcd_discovery_set &etcd_module::get_global_discovery() noexcept { return global_discovery_; }
-
-LIBATAPP_MACRO_API const etcd_discovery_set &etcd_module::get_global_discovery() const noexcept {
-  return global_discovery_;
-}
-
-LIBATAPP_MACRO_API const std::unordered_map<uint64_t, etcd_module::topology_storage_t> &
-etcd_module::get_topology_info_set() const noexcept {
-  return internal_topology_info_set_;
-}
-
-LIBATAPP_MACRO_API bool etcd_module::has_discovery_snapshot() const noexcept {
-  return !discovery_watcher_snapshot_index_.empty();
-}
-
-LIBATAPP_MACRO_API etcd_module::discovery_snapshot_event_callback_handle_t etcd_module::add_on_load_discovery_snapshot(
-    const discovery_snapshot_event_callback_t &fn) {
-  if (!fn) {
-    return discovery_on_load_snapshot_callbacks_.end();
-  }
-
-  return discovery_on_load_snapshot_callbacks_.insert(discovery_on_load_snapshot_callbacks_.end(), fn);
-}
-
-LIBATAPP_MACRO_API void etcd_module::remove_on_load_discovery_snapshot(
-    discovery_snapshot_event_callback_handle_t &handle) {
-  if (handle == discovery_on_load_snapshot_callbacks_.end()) {
-    return;
-  }
-
-  discovery_on_load_snapshot_callbacks_.erase(handle);
-  handle = discovery_on_load_snapshot_callbacks_.end();
-}
-
-LIBATAPP_MACRO_API etcd_module::discovery_snapshot_event_callback_handle_t
-etcd_module::add_on_discovery_snapshot_loaded(const discovery_snapshot_event_callback_t &fn) {
-  if (!fn) {
-    return discovery_on_snapshot_loaded_callbacks_.end();
-  }
-
-  return discovery_on_snapshot_loaded_callbacks_.insert(discovery_on_snapshot_loaded_callbacks_.end(), fn);
-}
-
-LIBATAPP_MACRO_API void etcd_module::remove_on_discovery_snapshot_loaded(
-    discovery_snapshot_event_callback_handle_t &handle) {
-  if (handle == discovery_on_snapshot_loaded_callbacks_.end()) {
-    return;
-  }
-
-  discovery_on_snapshot_loaded_callbacks_.erase(handle);
-  handle = discovery_on_snapshot_loaded_callbacks_.end();
-}
-
-LIBATAPP_MACRO_API bool etcd_module::has_topology_snapshot() const noexcept {
-  return !topology_watcher_snapshot_index_.empty();
-}
-
-LIBATAPP_MACRO_API etcd_module::topology_snapshot_event_callback_handle_t etcd_module::add_on_load_topology_snapshot(
-    const topology_snapshot_event_callback_t &fn) {
-  if (!fn) {
-    return topology_on_load_snapshot_callbacks_.end();
-  }
-
-  return topology_on_load_snapshot_callbacks_.insert(topology_on_load_snapshot_callbacks_.end(), fn);
-}
-
-LIBATAPP_MACRO_API void etcd_module::remove_on_load_topology_snapshot(
-    topology_snapshot_event_callback_handle_t &handle) {
-  if (handle == topology_on_load_snapshot_callbacks_.end()) {
-    return;
-  }
-
-  topology_on_load_snapshot_callbacks_.erase(handle);
-  handle = topology_on_load_snapshot_callbacks_.end();
-}
-
-LIBATAPP_MACRO_API etcd_module::topology_snapshot_event_callback_handle_t etcd_module::add_on_topology_snapshot_loaded(
-    const topology_snapshot_event_callback_t &fn) {
-  if (!fn) {
-    return topology_on_snapshot_loaded_callbacks_.end();
-  }
-
-  return topology_on_snapshot_loaded_callbacks_.insert(topology_on_snapshot_loaded_callbacks_.end(), fn);
-}
-
-LIBATAPP_MACRO_API void etcd_module::remove_on_topology_snapshot_loaded(
-    topology_snapshot_event_callback_handle_t &handle) {
-  if (handle == topology_on_snapshot_loaded_callbacks_.end()) {
-    return;
-  }
-
-  topology_on_snapshot_loaded_callbacks_.erase(handle);
-  handle = topology_on_snapshot_loaded_callbacks_.end();
-}
-
-LIBATAPP_MACRO_API etcd_watcher::watch_event_fn_t_ptr etcd_module::create_discovery_watcher_callback_list_wrapper() {
-  return std::make_unique<etcd_watcher::watch_event_fn_t>(
-      discovery_watcher_callback_list_wrapper_t(*this, ++discovery_watcher_snapshot_index_allocator_));
-}
-LIBATAPP_MACRO_API etcd_watcher::watch_event_fn_t_ptr etcd_module::create_topology_watcher_callback_list_wrapper() {
-  return std::make_unique<etcd_watcher::watch_event_fn_t>(
-      topology_watcher_callback_list_wrapper_t(*this, ++topology_watcher_snapshot_index_allocator_));
-}
-
-bool etcd_module::unpack(node_info_t &out, const std::string &path, const std::string &json, bool reset_data) {
-  if (reset_data) {
-    out.node_discovery.Clear();
-  }
-
-  if (json.empty()) {
-    size_t start_idx = 0;
-    size_t last_minus = 0;
-    for (size_t i = 0; i < path.size(); ++i) {
-      if (path[i] == '/' || path[i] == '\\' || path[i] == ' ' || path[i] == '\t' || path[i] == '\r' ||
-          path[i] == '\n') {
-        start_idx = i + 1;
-      } else if (path[i] == '-') {
-        last_minus = i;
-      }
-    }
-
-    // parse id from key if key is a number
-    if (start_idx < path.size()) {
-      if (last_minus + 1 < path.size() && last_minus >= start_idx) {
-        out.node_discovery.set_id(atfw::util::string::to_int<uint64_t>(path.c_str() + last_minus + 1));
-        out.node_discovery.set_name(path.substr(start_idx, last_minus - start_idx));
-      } else {
-        // old mode, only id on last segment
-        out.node_discovery.set_id(atfw::util::string::to_int<uint64_t>(&path[start_idx]));
-      }
-    }
-    return false;
-  }
-
-  ATBUS_MACRO_PROTOBUF_NAMESPACE_ID::util::JsonParseOptions options;
-  options.ignore_unknown_fields = true;
-
-  if (!ATBUS_MACRO_PROTOBUF_NAMESPACE_ID::util::JsonStringToMessage(json, &out.node_discovery, options).ok()) {
-    return false;
-  }
-
-  return true;
-}
-
-void etcd_module::pack(const node_info_t &src, std::string &json) {
-  ATBUS_MACRO_PROTOBUF_NAMESPACE_ID::util::JsonPrintOptions options;
-  options.add_whitespace = false;
-  options.always_print_enums_as_ints = true;
-  options.preserve_proto_field_names = true;
-  options.unquote_int64_if_possible = true;
-  if (!ATBUS_MACRO_PROTOBUF_NAMESPACE_ID::util::MessageToJsonString(src.node_discovery, &json, options).ok()) {
-    FWLOGERROR("etcd_module pack message to json failed");
-  }
-}
-
-bool etcd_module::unpack(topology_info_t &out, const std::string &path, const std::string &json, bool reset_data) {
-  if (reset_data && out.storage.info) {
-    out.storage.info->Clear();
-  }
-  if (!out.storage.info) {
-    out.storage.info = atfw::util::memory::make_strong_rc<atapp::protocol::atapp_topology_info>();
-  }
-
-  if (json.empty()) {
-    size_t start_idx = 0;
-    size_t last_minus = 0;
-    for (size_t i = 0; i < path.size(); ++i) {
-      if (path[i] == '/' || path[i] == '\\' || path[i] == ' ' || path[i] == '\t' || path[i] == '\r' ||
-          path[i] == '\n') {
-        start_idx = i + 1;
-      } else if (path[i] == '-') {
-        last_minus = i;
-      }
-    }
-
-    // parse id from key if key is a number
-    if (start_idx < path.size()) {
-      if (last_minus + 1 < path.size() && last_minus >= start_idx) {
-        out.storage.info->set_id(atfw::util::string::to_int<uint64_t>(path.c_str() + last_minus + 1));
-        out.storage.info->set_name(path.substr(start_idx, last_minus - start_idx));
-      } else {
-        // old mode, only id on last segment
-        out.storage.info->set_id(atfw::util::string::to_int<uint64_t>(&path[start_idx]));
-      }
-    }
-    return false;
-  }
-
-  ATBUS_MACRO_PROTOBUF_NAMESPACE_ID::util::JsonParseOptions options;
-  options.ignore_unknown_fields = true;
-
-  if (!ATBUS_MACRO_PROTOBUF_NAMESPACE_ID::util::JsonStringToMessage(json, out.storage.info.get(), options).ok()) {
-    return false;
-  }
-
-  return true;
-}
-
-void etcd_module::pack(const atapp::protocol::atapp_topology_info &src, std::string &json) {
-  ATBUS_MACRO_PROTOBUF_NAMESPACE_ID::util::JsonPrintOptions options;
-  options.add_whitespace = false;
-  options.always_print_enums_as_ints = true;
-  options.preserve_proto_field_names = true;
-  options.unquote_int64_if_possible = true;
-  if (!ATBUS_MACRO_PROTOBUF_NAMESPACE_ID::util::MessageToJsonString(src, &json, options).ok()) {
-    FWLOGERROR("etcd_module pack message to json failed");
-  }
-}
-
-int etcd_module::http_callback_on_etcd_closed(atfw::util::network::http_request &req) {
-  etcd_module *self = reinterpret_cast<etcd_module *>(req.get_priv_data());
-  if (nullptr == self) {
-    FWLOGERROR("etcd_module get request shouldn't has request without private data");
-    return 0;
-  }
-
-  self->cleanup_request_.reset();
-
-  LIBATAPP_MACRO_ETCD_CLUSTER_LOG_DEBUG(self->etcd_ctx_, "Etcd revoke lease finished");
-
-  // call stop to trigger stop process again.
-  if (nullptr != self->get_app()) {
-    self->get_app()->stop();
-  }
-
-  return 0;
-}
-
-namespace {
-static void _collect_old_nodes(etcd_module &mod, etcd_discovery_set::node_by_name_type &old_names,
-                               etcd_discovery_set::node_by_id_type &old_ids) {
-  old_ids.reserve(mod.get_global_discovery().get_sorted_nodes().size());
-  old_names.reserve(mod.get_global_discovery().get_sorted_nodes().size());
-  for (const auto &node : mod.get_global_discovery().get_sorted_nodes()) {
-    if (!node) {
-      continue;
-    }
-    if (0 != node->get_discovery_info().id()) {
-      old_ids[node->get_discovery_info().id()] = node;
-    } else if (!node->get_discovery_info().name().empty()) {
-      old_names[node->get_discovery_info().name()] = node;
-    }
-  }
-}
-
-static void _remove_old_node_index(const atapp::protocol::atapp_discovery &node_discovery,
-                                   etcd_discovery_set::node_by_name_type &old_names,
-                                   etcd_discovery_set::node_by_id_type &old_ids) {
-  if (0 != node_discovery.id()) {
-    old_ids.erase(node_discovery.id());
-  }
-  if (!node_discovery.name().empty()) {
-    old_names.erase(node_discovery.name());
-  }
-}
-}  // namespace
-
-void etcd_module::watcher_internal_access_t::cleanup_old_nodes(etcd_module &mod,
-                                                               etcd_discovery_set::node_by_name_type &old_names,
-                                                               etcd_discovery_set::node_by_id_type &old_ids) {
-  for (auto &node : old_names) {
-    etcd_module::node_info_t evt_node;
-    evt_node.action = etcd_module::node_action_t::kDelete;
-    node.second->copy_key_to(evt_node.node_discovery);
-    mod.update_internal_watcher_event(evt_node, node.second->get_version());
-  }
-
-  for (auto &node : old_ids) {
-    etcd_module::node_info_t evt_node;
-    evt_node.action = etcd_module::node_action_t::kDelete;
-    node.second->copy_key_to(evt_node.node_discovery);
-    mod.update_internal_watcher_event(evt_node, node.second->get_version());
-  }
-}
-
-namespace {
-static void _collect_old_topology_peers(etcd_module &mod,
-                                        std::unordered_map<uint64_t, etcd_module::topology_storage_t> &old_ids) {
-  old_ids.reserve(mod.get_topology_info_set().size());
-  old_ids = mod.get_topology_info_set();
-}
-
-static void _remove_old_topology_peer_index(const atapp::protocol::atapp_topology_info &topology_info,
-                                            std::unordered_map<uint64_t, etcd_module::topology_storage_t> &old_ids) {
-  if (0 != topology_info.id()) {
-    old_ids.erase(topology_info.id());
-  }
-}
-}  // namespace
-
-void etcd_module::watcher_internal_access_t::cleanup_old_topology_peers(
-    etcd_module &mod, std::unordered_map<uint64_t, etcd_module::topology_storage_t> &old_ids) {
-  for (auto &id : old_ids) {
-    etcd_module::topology_info_t evt_node;
-    evt_node.action = etcd_module::topology_action_t::kDelete;
-    evt_node.storage = id.second;
-    mod.update_internal_watcher_event(evt_node);
-  }
-}
-
-etcd_module::discovery_watcher_callback_list_wrapper_t::discovery_watcher_callback_list_wrapper_t(etcd_module &m,
-                                                                                                  int64_t index)
-    : mod(&m), callbacks(nullptr), snapshot_index(index), has_insert_snapshot_index(false) {}
-
-etcd_module::discovery_watcher_callback_list_wrapper_t::discovery_watcher_callback_list_wrapper_t(
-    etcd_module &m, std::list<discovery_watcher_list_callback_t> &cbks, int64_t index)
-    : mod(&m), callbacks(&cbks), snapshot_index(index), has_insert_snapshot_index(false) {}
-
-etcd_module::discovery_watcher_callback_list_wrapper_t::~discovery_watcher_callback_list_wrapper_t() {
-  if (nullptr != mod && 0 != snapshot_index && has_insert_snapshot_index) {
-    mod->discovery_watcher_snapshot_index_.erase(snapshot_index);
-  }
-}
-
-void etcd_module::discovery_watcher_callback_list_wrapper_t::operator()(
-    const ::atframework::atapp::etcd_response_header &header,
-    const ::atframework::atapp::etcd_watcher::response_t &body) {
-  if (nullptr == mod) {
-    return;
-  }
-  mod->last_etcd_event_discovery_header_ = header;
-
-  bool enable_snapshot = body.snapshot && 0 != snapshot_index;
-  if (enable_snapshot) {
-    if (!has_insert_snapshot_index) {
-      mod->discovery_watcher_snapshot_index_.insert(snapshot_index);
-      has_insert_snapshot_index = true;
-    }
-
-    // We just accept the earliest watcher as snapshot notifier.
-    // So just enable by_id or by_name when initializing and they will has the smallest index.
-    if (!mod->discovery_watcher_snapshot_index_.empty() &&
-        *mod->discovery_watcher_snapshot_index_.begin() != snapshot_index) {
-      enable_snapshot = false;
-    }
-  }
-
-  etcd_discovery_set::node_by_name_type old_names;
-  etcd_discovery_set::node_by_id_type old_ids;
-  if (enable_snapshot) {
-    _collect_old_nodes(*mod, old_names, old_ids);
-
-    for (auto iter = mod->discovery_on_load_snapshot_callbacks_.begin();
-         iter != mod->discovery_on_load_snapshot_callbacks_.end();) {
-      auto copy_iter = iter;
-      ++iter;
-      if (*copy_iter) {
-        (*copy_iter)(*mod);
-      }
-    }
-  }
-
-  // decode data
-  for (size_t i = 0; i < body.events.size(); ++i) {
-    const ::atframework::atapp::etcd_watcher::event_t &evt_data = body.events[i];
-    node_info_t node;
-    etcd_discovery_node::node_version current_node_version;
-
-    unpack(node, evt_data.kv.key.empty() ? evt_data.prev_kv.key : evt_data.kv.key,
-           evt_data.kv.value.empty() ? evt_data.prev_kv.value : evt_data.kv.value, true);
-    current_node_version.create_revision = std::max(evt_data.prev_kv.create_revision, evt_data.kv.create_revision);
-    current_node_version.modify_revision = std::max(evt_data.prev_kv.mod_revision, evt_data.kv.mod_revision);
-    current_node_version.version = std::max(evt_data.prev_kv.version, evt_data.kv.version);
-
-    if (node.node_discovery.id() == 0 && node.node_discovery.name().empty()) {
-      continue;
-    }
-
-    if (enable_snapshot) {
-      _remove_old_node_index(node.node_discovery, old_names, old_ids);
-    }
-
-    if (evt_data.evt_type == ::atframework::atapp::etcd_watch_event::kDelete) {
-      node.action = node_action_t::kDelete;
-    } else {
-      node.action = node_action_t::kPut;
-    }
-
-    mod->update_internal_watcher_event(node, current_node_version);
-
-    if (nullptr == callbacks) {
-      continue;
-    }
-
-    if (callbacks->empty()) {
-      continue;
-    }
-
-    discovery_watcher_sender_list_t sender(*mod, header, body, evt_data, node);
-    for (std::list<discovery_watcher_list_callback_t>::iterator iter = callbacks->begin(); iter != callbacks->end();
-         ++iter) {
-      if (*iter) {
-        (*iter)(std::ref(sender));
-      }
-    }
-  }
-
-  // cleanup old nodes when receive snapshot response
-  if (enable_snapshot) {
-    etcd_module::watcher_internal_access_t::cleanup_old_nodes(*mod, old_names, old_ids);
-
-    for (auto iter = mod->discovery_on_snapshot_loaded_callbacks_.begin();
-         iter != mod->discovery_on_snapshot_loaded_callbacks_.end();) {
-      auto copy_iter = iter;
-      ++iter;
-      if (*copy_iter) {
-        (*copy_iter)(*mod);
-      }
-    }
-  }
-}
-
-etcd_module::topology_watcher_callback_list_wrapper_t::topology_watcher_callback_list_wrapper_t(etcd_module &m,
-                                                                                                int64_t index)
-    : mod(&m), callbacks(nullptr), snapshot_index(index), has_insert_snapshot_index(false) {}
-
-etcd_module::topology_watcher_callback_list_wrapper_t::topology_watcher_callback_list_wrapper_t(
-    etcd_module &m, std::list<topology_watcher_list_callback_t> &cbks, int64_t index)
-    : mod(&m), callbacks(&cbks), snapshot_index(index), has_insert_snapshot_index(false) {}
-
-etcd_module::topology_watcher_callback_list_wrapper_t::~topology_watcher_callback_list_wrapper_t() {
-  if (nullptr != mod && 0 != snapshot_index && has_insert_snapshot_index) {
-    mod->topology_watcher_snapshot_index_.erase(snapshot_index);
-  }
-}
-
-void etcd_module::topology_watcher_callback_list_wrapper_t::operator()(
-    const ::atframework::atapp::etcd_response_header &header,
-    const ::atframework::atapp::etcd_watcher::response_t &body) {
-  if (nullptr == mod) {
-    return;
-  }
-  mod->last_etcd_event_topology_header_ = header;
-
-  bool enable_snapshot = body.snapshot && 0 != snapshot_index;
-  if (enable_snapshot) {
-    if (!has_insert_snapshot_index) {
-      mod->topology_watcher_snapshot_index_.insert(snapshot_index);
-      has_insert_snapshot_index = true;
-    }
-
-    // We just accept the earliest watcher as snapshot notifier.
-    // So just enable by_id or by_name when initializing and they will has the smallest index.
-    if (!mod->topology_watcher_snapshot_index_.empty() &&
-        *mod->topology_watcher_snapshot_index_.begin() != snapshot_index) {
-      enable_snapshot = false;
-    }
-  }
-
-  std::unordered_map<uint64_t, topology_storage_t> old_ids;
-  if (enable_snapshot) {
-    _collect_old_topology_peers(*mod, old_ids);
-
-    for (auto iter = mod->topology_on_load_snapshot_callbacks_.begin();
-         iter != mod->topology_on_load_snapshot_callbacks_.end();) {
-      auto copy_iter = iter;
-      ++iter;
-      if (*copy_iter) {
-        (*copy_iter)(*mod);
-      }
-    }
-  }
-
-  // decode data
-  for (size_t i = 0; i < body.events.size(); ++i) {
-    const ::atframework::atapp::etcd_watcher::event_t &evt_data = body.events[i];
-    topology_info_t topology_info;
-
-    unpack(topology_info, evt_data.kv.key.empty() ? evt_data.prev_kv.key : evt_data.kv.key,
-           evt_data.kv.value.empty() ? evt_data.prev_kv.value : evt_data.kv.value, true);
-    topology_info.storage.version.create_revision =
-        std::max(evt_data.prev_kv.create_revision, evt_data.kv.create_revision);
-    topology_info.storage.version.modify_revision = std::max(evt_data.prev_kv.mod_revision, evt_data.kv.mod_revision);
-    topology_info.storage.version.version = std::max(evt_data.prev_kv.version, evt_data.kv.version);
-
-    if (!topology_info.storage.info || topology_info.storage.info->id() == 0) {
-      continue;
-    }
-
-    if (enable_snapshot) {
-      _remove_old_topology_peer_index(*topology_info.storage.info, old_ids);
-    }
-    topology_info.action = evt_data.evt_type;
-
-    mod->update_internal_watcher_event(topology_info);
-
-    if (nullptr == callbacks) {
-      continue;
-    }
-
-    if (callbacks->empty()) {
-      continue;
-    }
-
-    topology_watcher_sender_list_t sender(*mod, header, body, evt_data, topology_info);
-    for (std::list<topology_watcher_list_callback_t>::iterator iter = callbacks->begin(); iter != callbacks->end();
-         ++iter) {
-      if (*iter) {
-        (*iter)(std::ref(sender));
-      }
-    }
-  }
-
-  // cleanup old nodes when receive snapshot response
-  if (enable_snapshot) {
-    etcd_module::watcher_internal_access_t::cleanup_old_topology_peers(*mod, old_ids);
-
-    for (auto iter = mod->topology_on_snapshot_loaded_callbacks_.begin();
-         iter != mod->topology_on_snapshot_loaded_callbacks_.end();) {
-      auto copy_iter = iter;
-      ++iter;
-      if (*copy_iter) {
-        (*copy_iter)(*mod);
-      }
-    }
-  }
-}
-
-bool etcd_module::update_internal_watcher_event(node_info_t &node, const etcd_discovery_node::node_version &version) {
-  etcd_discovery_node::ptr_t local_cache_by_id = global_discovery_.get_node_by_id(node.node_discovery.id());
-  etcd_discovery_node::ptr_t local_cache_by_name = global_discovery_.get_node_by_name(node.node_discovery.name());
-  etcd_discovery_node::ptr_t new_inst;
-
-  bool has_event = false;
-
-  if ATFW_UTIL_LIKELY_CONDITION (local_cache_by_id == local_cache_by_name) {
-    if (node_action_t::kDelete == node.action) {
-      if (local_cache_by_id) {
-        local_cache_by_id->update_version(version, true);
-        global_discovery_.remove_node(local_cache_by_id);
-
-        has_event = true;
-      }
-    } else {
-      if (local_cache_by_id && protobuf_equal(local_cache_by_id->get_discovery_info(), node.node_discovery)) {
-        return false;
-      }
-
-      if (local_cache_by_id) {
-        new_inst = local_cache_by_id;
-      } else {
-        new_inst = atfw::util::memory::make_strong_rc<etcd_discovery_node>();
-      }
-
-      new_inst->copy_from(node.node_discovery, version);
-      global_discovery_.add_node(new_inst);
-
-      has_event = true;
-    }
-  } else {
-    if (node_action_t::kDelete == node.action) {
-      if (local_cache_by_id) {
-        local_cache_by_id->update_version(version, true);
-        global_discovery_.remove_node(local_cache_by_id);
-        has_event = true;
-      }
-      if (local_cache_by_name) {
-        local_cache_by_name->update_version(version, true);
-        global_discovery_.remove_node(local_cache_by_name);
-        has_event = true;
-      }
-    } else {
-      if ((!local_cache_by_id && 0 != node.node_discovery.id()) ||
-          (!local_cache_by_name && !node.node_discovery.name().empty())) {
-        has_event = true;
-      } else if (local_cache_by_id &&
-                 false == protobuf_equal(local_cache_by_id->get_discovery_info(), node.node_discovery)) {
-        has_event = true;
-      } else if (local_cache_by_name &&
-                 false == protobuf_equal(local_cache_by_name->get_discovery_info(), node.node_discovery)) {
-        has_event = true;
-      }
-
-      if (has_event) {
-        if (local_cache_by_id) {
-          new_inst = local_cache_by_id;
-        } else if (local_cache_by_name) {
-          new_inst = local_cache_by_name;
-        } else {
-          new_inst = atfw::util::memory::make_strong_rc<etcd_discovery_node>();
-        }
-        new_inst->copy_from(node.node_discovery, version);
-
-        if (local_cache_by_id && local_cache_by_id != new_inst) {
-          local_cache_by_id->update_version(version, false);
-          global_discovery_.remove_node(local_cache_by_id);
-        }
-        if (local_cache_by_name && local_cache_by_name != new_inst) {
-          local_cache_by_name->update_version(version, false);
-          global_discovery_.remove_node(local_cache_by_name);
-        }
-
-        global_discovery_.add_node(new_inst);
-      }
-    }
-  }
-
-  // remove endpoint if got DELETE event
-  if (has_event) {
-    app *owner = get_app();
-    if (node_action_t::kDelete == node.action && nullptr != owner) {
-      if (0 != node.node_discovery.id()) {
-        owner->remove_endpoint(node.node_discovery.id());
-      }
-      if (!node.node_discovery.name().empty()) {
-        owner->remove_endpoint(node.node_discovery.name());
-      }
-    }
-
-    if (nullptr != owner) {
-      std::lock_guard<std::recursive_mutex> lock_guard{node_event_lock_};
-
-      // notify all connector discovery event
-      if (new_inst) {
-        owner->trigger_event_on_discovery_event(node.action, new_inst);
-        for (node_event_callback_list_t::iterator iter = node_event_callbacks_.begin();
-             iter != node_event_callbacks_.end(); ++iter) {
-          if (*iter) {
-            (*iter)(node.action, new_inst);
-          }
-        }
-      } else if (local_cache_by_name) {
-        owner->trigger_event_on_discovery_event(node.action, local_cache_by_name);
-        for (node_event_callback_list_t::iterator iter = node_event_callbacks_.begin();
-             iter != node_event_callbacks_.end(); ++iter) {
-          if (*iter) {
-            (*iter)(node.action, local_cache_by_name);
-          }
-        }
-      } else {
-        owner->trigger_event_on_discovery_event(node.action, local_cache_by_id);
-        for (node_event_callback_list_t::iterator iter = node_event_callbacks_.begin();
-             iter != node_event_callbacks_.end(); ++iter) {
-          if (*iter) {
-            (*iter)(node.action, local_cache_by_id);
-          }
-        }
-      }
-    }
-  }
-
-  return has_event;
-}
-
-bool etcd_module::update_internal_watcher_event(topology_info_t &topology_info) {
-  if (!topology_info.storage.info) {
-    return false;
-  }
-
-  atapp_topology_info_ptr_t info_ptr{};
-  if (topology_info.action == topology_action_t::kDelete) {
-    std::unordered_map<uint64_t, topology_storage_t>::iterator local_cache_iter =
-        internal_topology_info_set_.find(topology_info.storage.info->id());
-    if (local_cache_iter == internal_topology_info_set_.end()) {
-      return false;
-    }
-
-    info_ptr = local_cache_iter->second.info;
-    internal_topology_info_set_.erase(local_cache_iter);
-  } else {
-    std::unordered_map<uint64_t, topology_storage_t>::iterator local_cache_iter =
-        internal_topology_info_set_.find(topology_info.storage.info->id());
-    if (local_cache_iter != internal_topology_info_set_.end()) {
-      bool changed = topology_update_version(local_cache_iter->second, topology_info.storage.version, true);
-
-      // 未变化
-      if (local_cache_iter->second.info &&
-          atapp_topology_equal(*local_cache_iter->second.info, *topology_info.storage.info)) {
-        return false;
-      }
-
-      if (changed) {
-        local_cache_iter->second.info = topology_info.storage.info;
-        info_ptr = local_cache_iter->second.info;
-      }
-    } else {
-      internal_topology_info_set_[topology_info.storage.info->id()] = topology_info.storage;
-      info_ptr = topology_info.storage.info;
-    }
-  }
-
-  app *owner = get_app();
-  if (owner != nullptr) {
-    std::lock_guard<std::recursive_mutex> lock_guard{topology_info_event_lock_};
-    owner->trigger_event_on_topology_event(topology_info.action, info_ptr, topology_info.storage.version);
-
-    for (topology_info_event_callback_list_t::iterator iter = topology_info_event_callbacks_.begin();
-         iter != topology_info_event_callbacks_.end(); ++iter) {
-      if (*iter) {
-        (*iter)(topology_info.action, info_ptr, topology_info.storage.version);
-      }
-    }
-  }
-  return true;
-}
-
-void etcd_module::reset_internal_watchers_and_keepalives() {
-  if (internal_discovery_watcher_by_name_) {
-    etcd_ctx_.remove_watcher(internal_discovery_watcher_by_name_);
-    internal_discovery_watcher_by_name_.reset();
-  }
-
-  if (internal_discovery_watcher_by_id_) {
-    etcd_ctx_.remove_watcher(internal_discovery_watcher_by_id_);
-    internal_discovery_watcher_by_id_.reset();
-  }
-
-  if (internal_topology_watcher_) {
-    etcd_ctx_.remove_watcher(internal_topology_watcher_);
-    internal_topology_watcher_.reset();
-  }
-
-  internal_discovery_keepalive_actors_.clear();
-  internal_topology_keepalive_actors_.clear();
-}
+LIBATAPP_MACRO_API const atapp::protocol::atapp_etcd &etcd_module::get_configure() const { return conf_cache_; }
 
 LIBATAPP_MACRO_NAMESPACE_END
diff --git a/src/atframe/modules/service_discovery_module.cpp b/src/atframe/modules/service_discovery_module.cpp
new file mode 100644
index 0000000..bcc0d23
--- /dev/null
+++ b/src/atframe/modules/service_discovery_module.cpp
@@ -0,0 +1,1556 @@
+// Copyright 2026 atframework
+// Created by yousongyang
+
+#include "atframe/modules/service_discovery_module.h"
+
+// clang-format off
+#include <config/compiler/protobuf_prefix.h>
+// clang-format on
+
+#include <google/protobuf/util/json_util.h>
+
+// clang-format off
+#include <config/compiler/protobuf_suffix.h>
+// clang-format on
+
+#include <common/string_oprs.h>
+#include <random/random_generator.h>
+
+#include <atframe/atapp.h>
+#include <atframe/atapp_conf.h>
+
+#include <atframe/etcdcli/etcd_cluster.h>
+#include <atframe/etcdcli/etcd_keepalive.h>
+#include <atframe/etcdcli/etcd_watcher.h>
+#include <atframe/modules/etcd_module.h>
+
+#include <algorithm>
+#include <memory>
+#include <string>
+#include <unordered_map>
+#include <utility>
+#include <vector>
+#include <set>
+
+#if defined(max)
+#  undef max
+#endif
+
+#if defined(min)
+#  undef min
+#endif
+
+#define ETCD_MODULE_BY_ID_DIR "by_id"
+#define ETCD_MODULE_BY_NAME_DIR "by_name"
+#define ETCD_MODULE_TOPOLOGY_DIR "topology"
+
+LIBATAPP_MACRO_NAMESPACE_BEGIN
+namespace {
+
+static bool atapp_discovery_equal(const atapp::protocol::atapp_area &l, const atapp::protocol::atapp_area &r) {
+  if (l.zone_id() != r.zone_id()) {
+    return false;
+  }
+  if (l.region().size() != r.region().size()) {
+    return false;
+  }
+  if (l.district().size() != r.district().size()) {
+    return false;
+  }
+  if (l.region() != r.region()) {
+    return false;
+  }
+  if (l.district() != r.district()) {
+    return false;
+  }
+
+  return true;
+}
+
+static bool atapp_topology_equal(const atapp::protocol::atapp_topology_info &l,
+                                 const atapp::protocol::atapp_topology_info &r) {
+  if (l.id() != r.id()) {
+    return false;
+  }
+  if (l.upstream_id() != r.upstream_id()) {
+    return false;
+  }
+  if (l.name() != r.name()) {
+    return false;
+  }
+
+  if (l.data().label().size() != r.data().label().size()) {
+    return false;
+  }
+
+  for (const auto &kv : l.data().label()) {
+    auto it = r.data().label().find(kv.first);
+    if (it == r.data().label().end()) {
+      return false;
+    }
+    if (it->second != kv.second) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+static bool topology_update_version(service_discovery_module::topology_storage_t &storage,
+                                    const etcd_data_version &new_version, bool upgrade, uintptr_t context_ptr) {
+  bool ret = false;
+  if (upgrade) {
+    if (new_version.create_revision > storage.version.create_revision) {
+      storage.version.create_revision = new_version.create_revision;
+      storage.version.version = new_version.version;
+      ret = true;
+    }
+
+    if (new_version.modify_revision > storage.version.modify_revision) {
+      storage.version.modify_revision = new_version.modify_revision;
+      storage.version.version = new_version.version;
+      ret = true;
+    }
+
+    if (new_version.version > storage.version.version) {
+      storage.version.version = new_version.version;
+      ret = true;
+    }
+  } else {
+    storage.version = new_version;
+    ret = true;
+  }
+  if (ret) {
+    storage.context_ptr = context_ptr;
+  }
+
+  return ret;
+}
+}  // namespace
+
+struct ATFW_UTIL_SYMBOL_LOCAL service_discovery_module::topology_watcher_callback_list_wrapper_t {
+  service_discovery_module *mod;
+  service_discovery_cluster_context *ctx;
+
+  std::recursive_mutex *callback_lock;
+  std::list<topology_watcher_list_callback_t> *callbacks;
+  int64_t snapshot_index;
+  bool has_insert_snapshot_index;
+
+  topology_watcher_callback_list_wrapper_t(service_discovery_module &m, service_discovery_cluster_context &c,
+                                           int64_t index);
+  topology_watcher_callback_list_wrapper_t(service_discovery_module &m, service_discovery_cluster_context &c,
+                                           std::recursive_mutex &lock,
+                                           std::list<topology_watcher_list_callback_t> &cbks, int64_t index);
+  ~topology_watcher_callback_list_wrapper_t();
+  void operator()(const ::atframework::atapp::etcd_response_header &header,
+                  const ::atframework::atapp::etcd_watcher::response_t &body);
+};
+
+struct ATFW_UTIL_SYMBOL_LOCAL service_discovery_module::discovery_watcher_callback_list_wrapper_t {
+  service_discovery_module *mod;
+  service_discovery_cluster_context *ctx;
+
+  std::recursive_mutex *callback_lock;
+  std::list<discovery_watcher_list_callback_t> *callbacks;
+  int64_t snapshot_index;
+  bool has_insert_snapshot_index;
+
+  discovery_watcher_callback_list_wrapper_t(service_discovery_module &m, service_discovery_cluster_context &c,
+                                            int64_t index);
+  discovery_watcher_callback_list_wrapper_t(service_discovery_module &m, service_discovery_cluster_context &c,
+                                            std::recursive_mutex &lock,
+                                            std::list<discovery_watcher_list_callback_t> &cbks, int64_t index);
+  ~discovery_watcher_callback_list_wrapper_t();
+  void operator()(const ::atframework::atapp::etcd_response_header &header,
+                  const ::atframework::atapp::etcd_watcher::response_t &body);
+};
+
+struct ATFW_UTIL_SYMBOL_LOCAL service_discovery_module::watcher_internal_access_t {
+  static void cleanup_old_nodes(service_discovery_module &mod, service_discovery_cluster_context &c,
+                                etcd_discovery_set::node_by_name_type &old_names,
+                                etcd_discovery_set::node_by_id_type &old_ids);
+  static void cleanup_old_topology_peers(service_discovery_module &mod, service_discovery_cluster_context &c,
+                                         std::unordered_map<uint64_t, topology_storage_t> &old_ids);
+};
+
+struct ATFW_UTIL_SYMBOL_LOCAL service_discovery_module::service_discovery_cluster_context_data {
+  service_discovery_cluster_context_data()
+      : last_etcd_event_topology_header_{},
+        last_etcd_event_discovery_header_{},
+        discovery_watcher_snapshot_index_allocator_(0),
+        topology_watcher_snapshot_index_allocator_(0) {
+    last_etcd_event_topology_header_.cluster_id = 0;
+    last_etcd_event_topology_header_.member_id = 0;
+    last_etcd_event_topology_header_.raft_term = 0;
+    last_etcd_event_topology_header_.revision = 0;
+
+    last_etcd_event_discovery_header_.cluster_id = 0;
+    last_etcd_event_discovery_header_.member_id = 0;
+    last_etcd_event_discovery_header_.raft_term = 0;
+    last_etcd_event_discovery_header_.revision = 0;
+  }
+
+  ::atframework::atapp::etcd_response_header last_etcd_event_topology_header_;
+  ::atframework::atapp::etcd_response_header last_etcd_event_discovery_header_;
+
+  std::set<int64_t> discovery_watcher_snapshot_index_;
+  int64_t discovery_watcher_snapshot_index_allocator_;
+  std::set<int64_t> topology_watcher_snapshot_index_;
+  int64_t topology_watcher_snapshot_index_allocator_;
+  etcd_watcher::ptr_t internal_topology_watcher_;
+  etcd_watcher::ptr_t internal_discovery_watcher_by_name_;
+  etcd_watcher::ptr_t internal_discovery_watcher_by_id_;
+
+  std::list<etcd_keepalive::ptr_t> internal_topology_keepalive_actors_;
+  std::list<etcd_keepalive::ptr_t> internal_discovery_keepalive_actors_;
+
+  std::list<discovery_watcher_list_callback_t> discovery_watcher_by_id_callbacks_;
+  std::list<discovery_watcher_list_callback_t> discovery_watcher_by_name_callbacks_;
+  std::list<topology_watcher_list_callback_t> topology_watcher_callbacks_;
+
+  mutable std::recursive_mutex discovery_watcher_callback_lock_;
+  mutable std::recursive_mutex topology_watcher_callback_lock_;
+};
+
+LIBATAPP_MACRO_API
+service_discovery_module::service_discovery_module()
+    : discovery_enabled_(true),
+      maybe_update_internal_keepalive_topology_value_(true),
+      maybe_update_internal_keepalive_discovery_value_(true),
+      maybe_update_internal_keepalive_discovery_area_(false),
+      maybe_update_internal_keepalive_discovery_metadata_(false) {}
+
+LIBATAPP_MACRO_API int service_discovery_module::init() {
+  int ret = cluster_context_.init(*get_app(), get_app()->get_origin_configure().etcd(), nullptr);
+  if (ret < 0) {
+    return ret;
+  }
+
+  if (!is_discovery_enabled()) {
+    return 0;
+  }
+
+  ret = init_service_discovery_keepalives_watchers(cluster_context_);
+  if (ret < 0) {
+    stop();
+    return ret;
+  }
+
+  if (!cluster_context_.check_keepalive_actor_start_success()) {
+    stop();
+    return -1;
+  }
+
+  return 0;
+}
+
+LIBATAPP_MACRO_API const char *ATFW_UTIL_MACRO_NONNULL service_discovery_module::name() const {
+  return "atapp: service_discovery module";
+}
+
+LIBATAPP_MACRO_API service_discovery_module::service_discovery_cluster_context::service_discovery_cluster_context()
+    : data_(std::make_shared<service_discovery_cluster_context_data>()) {}
+
+LIBATAPP_MACRO_API int service_discovery_module::stop() { return cluster_context_.stop(); }
+
+LIBATAPP_MACRO_API int service_discovery_module::reload() {
+  return cluster_context_.reload(get_app()->get_origin_configure().etcd(), nullptr);
+}
+
+LIBATAPP_MACRO_API int service_discovery_module::tick() {
+  cluster_context_.tick();
+
+  update_keepalive_topology_value();
+  if (cluster_context_.get_etcd_module().get_etcd_cluster().check_flag(etcd_cluster::flag_t::kRunning)) {
+    update_keepalive_discovery_value();
+  }
+
+  return 0;
+}
+
+LIBATAPP_MACRO_API bool service_discovery_module::is_discovery_enabled() const {
+  return cluster_context_.get_etcd_module().is_etcd_enabled() && discovery_enabled_;
+}
+
+LIBATAPP_MACRO_API void service_discovery_module::enable_discovery() {
+  if (is_discovery_enabled()) {
+    return;
+  }
+  discovery_enabled_ = true;
+  if (!is_discovery_enabled()) {
+    return;
+  }
+  init_service_discovery_keepalives_watchers(cluster_context_);
+}
+
+LIBATAPP_MACRO_API void service_discovery_module::disable_discovery() {
+  if (!is_discovery_enabled()) {
+    return;
+  }
+  discovery_enabled_ = false;
+  cluster_context_.reset_internal_watchers_and_keepalives();
+}
+
+void service_discovery_module::update_keepalive_topology_value() {
+  if (!maybe_update_internal_keepalive_topology_value_ || nullptr == get_app()) {
+    return;
+  }
+  maybe_update_internal_keepalive_topology_value_ = false;
+
+  atapp_topology_info_ptr_t topology_ptr = atfw::util::memory::make_strong_rc<atapp::protocol::atapp_topology_info>();
+  get_app()->pack(*topology_ptr);
+
+  if (last_submitted_topology_data_ && atapp_topology_equal(*topology_ptr, *last_submitted_topology_data_)) {
+    return;
+  }
+  last_submitted_topology_data_ = topology_ptr;
+
+  std::string new_value;
+  pack(*topology_ptr, new_value);
+
+  if (new_value != internal_keepalive_topology_value_) {
+    internal_keepalive_topology_value_.swap(new_value);
+
+    for (std::list<etcd_keepalive::ptr_t>::iterator iter =
+             cluster_context_.data_->internal_topology_keepalive_actors_.begin();
+         iter != cluster_context_.data_->internal_topology_keepalive_actors_.end(); ++iter) {
+      if (*iter) {
+        (*iter)->set_value(internal_keepalive_topology_value_);
+      }
+    }
+  }
+}
+
+void service_discovery_module::update_keepalive_discovery_value() {
+  if (!(maybe_update_internal_keepalive_discovery_value_ || maybe_update_internal_keepalive_discovery_area_ ||
+        maybe_update_internal_keepalive_discovery_metadata_) ||
+      nullptr == get_app()) {
+    return;
+  }
+
+  std::string new_value;
+  node_info_t ni;
+  get_app()->pack(ni.node_discovery);
+
+  bool has_changed = maybe_update_internal_keepalive_discovery_value_;
+  maybe_update_internal_keepalive_discovery_value_ = false;
+  if (maybe_update_internal_keepalive_discovery_area_) {
+    if (!atapp_discovery_equal(ni.node_discovery.area(), last_submitted_discovery_data_area_)) {
+      has_changed = true;
+      last_submitted_discovery_data_area_ = ni.node_discovery.area();
+    }
+  }
+  maybe_update_internal_keepalive_discovery_area_ = false;
+  if (maybe_update_internal_keepalive_discovery_metadata_) {
+    if (!etcd_discovery_set::metadata_equal_type()(ni.node_discovery.metadata(),
+                                                   last_submitted_discovery_data_metadata_)) {
+      has_changed = true;
+      last_submitted_discovery_data_metadata_ = ni.node_discovery.metadata();
+    }
+  }
+  maybe_update_internal_keepalive_discovery_metadata_ = false;
+
+  if (!has_changed) {
+    return;
+  }
+
+  pack(ni, new_value);
+  if (new_value != internal_keepalive_discovery_value_) {
+    internal_keepalive_discovery_value_.swap(new_value);
+
+    for (std::list<etcd_keepalive::ptr_t>::iterator iter =
+             cluster_context_.data_->internal_discovery_keepalive_actors_.begin();
+         iter != cluster_context_.data_->internal_discovery_keepalive_actors_.end(); ++iter) {
+      if (*iter) {
+        (*iter)->set_value(internal_keepalive_discovery_value_);
+      }
+    }
+  }
+}
+
+LIBATAPP_MACRO_API int service_discovery_module::init_service_discovery_keepalives_watchers(
+    service_discovery_cluster_context &context) {
+  // 先刷新topology数据，后刷新discovery数据，以保证策略路由变化时已获取到最新的topology信息
+  update_keepalive_topology_value();
+  update_keepalive_discovery_value();
+
+  atframework::atapp::app &app = *get_app();
+
+  int ret = init_topology_keepalive(app, context, internal_keepalive_topology_value_);
+  if (ret < 0) {
+    return ret;
+  }
+  ret = init_discovery_keepalive_by_id(app, context, internal_keepalive_discovery_value_);
+  if (ret < 0) {
+    return ret;
+  }
+  ret = init_discovery_keepalive_by_name(app, context, internal_keepalive_discovery_value_);
+  if (ret < 0) {
+    return ret;
+  }
+
+  ret = add_topology_watcher_callback(nullptr);
+  if (ret < 0) {
+    return ret;
+  }
+  ret = add_discovery_watcher_by_id_callback(nullptr);
+  if (ret < 0) {
+    return ret;
+  }
+  ret = add_discovery_watcher_by_name_callback(nullptr);
+  if (ret < 0) {
+    return ret;
+  }
+
+  return 0;
+}
+
+LIBATAPP_MACRO_API int service_discovery_module::init_discovery_keepalive_by_id(
+    atframework::atapp::app &app, service_discovery_cluster_context &context, std::string &value) {
+  atapp::etcd_keepalive::ptr_t actor = add_keepalive_actor(
+      app, context, value, get_discovery_by_id_path(app, context.etcd_module_.get_configure_path()));
+  if (!actor) {
+    LIBATAPP_MACRO_ETCD_CLUSTER_LOG_ERROR(context.etcd_module_.get_etcd_cluster(),
+                                          "create etcd_keepalive for by_id index failed.");
+    return -1;
+  }
+
+  context.data_->internal_discovery_keepalive_actors_.push_back(actor);
+  LIBATAPP_MACRO_ETCD_CLUSTER_LOG_INFO(context.etcd_module_.get_etcd_cluster(),
+                                       "create etcd_keepalive {} for by_id index {} success",
+                                       reinterpret_cast<const void *>(actor.get()),
+                                       get_discovery_by_id_path(app, context.etcd_module_.get_configure_path()));
+  return 0;
+}
+
+LIBATAPP_MACRO_API int service_discovery_module::init_discovery_keepalive_by_name(
+    atframework::atapp::app &app, service_discovery_cluster_context &context, std::string &value) {
+  atapp::etcd_keepalive::ptr_t actor = add_keepalive_actor(
+      app, context, value, get_discovery_by_name_path(app, context.etcd_module_.get_configure_path()));
+  if (!actor) {
+    LIBATAPP_MACRO_ETCD_CLUSTER_LOG_ERROR(context.etcd_module_.get_etcd_cluster(),
+                                          "create etcd_keepalive for by_name index failed.");
+    return -1;
+  }
+
+  context.data_->internal_discovery_keepalive_actors_.push_back(actor);
+  LIBATAPP_MACRO_ETCD_CLUSTER_LOG_INFO(context.etcd_module_.get_etcd_cluster(),
+                                       "create etcd_keepalive {} for by_name index {} success",
+                                       reinterpret_cast<const void *>(actor.get()),
+                                       get_discovery_by_name_path(app, context.etcd_module_.get_configure_path()));
+  return 0;
+}
+
+LIBATAPP_MACRO_API int service_discovery_module::init_topology_keepalive(atframework::atapp::app &app,
+                                                                         service_discovery_cluster_context &context,
+                                                                         std::string &value) {
+  atapp::etcd_keepalive::ptr_t actor =
+      add_keepalive_actor(app, context, value, get_topology_path(app, context.etcd_module_.get_configure_path()));
+  if (!actor) {
+    LIBATAPP_MACRO_ETCD_CLUSTER_LOG_ERROR(context.etcd_module_.get_etcd_cluster(),
+                                          "create etcd_keepalive for topology index failed.");
+    return -1;
+  }
+
+  context.data_->internal_topology_keepalive_actors_.push_back(actor);
+  LIBATAPP_MACRO_ETCD_CLUSTER_LOG_INFO(
+      context.etcd_module_.get_etcd_cluster(), "create etcd_keepalive {} for topology index {} success",
+      reinterpret_cast<const void *>(actor.get()), get_topology_path(app, context.etcd_module_.get_configure_path()));
+  return 0;
+}
+
+LIBATAPP_MACRO_API void service_discovery_module::set_maybe_update_keepalive_topology_value() {
+  maybe_update_internal_keepalive_topology_value_ = true;
+}
+
+LIBATAPP_MACRO_API void service_discovery_module::set_maybe_update_keepalive_discovery_value() {
+  maybe_update_internal_keepalive_discovery_value_ = true;
+}
+
+LIBATAPP_MACRO_API void service_discovery_module::set_maybe_update_keepalive_discovery_area() {
+  maybe_update_internal_keepalive_discovery_area_ = true;
+}
+
+LIBATAPP_MACRO_API void service_discovery_module::set_maybe_update_keepalive_discovery_metadata() {
+  maybe_update_internal_keepalive_discovery_metadata_ = true;
+}
+
+LIBATAPP_MACRO_API std::string service_discovery_module::get_discovery_by_id_path(atframework::atapp::app &app,
+                                                                                  const std::string &path) {
+  return LOG_WRAPPER_FWAPI_FORMAT("{}{}/{}-{}", path, ETCD_MODULE_BY_ID_DIR, app.get_app_name(), app.get_id());
+}
+
+LIBATAPP_MACRO_API std::string service_discovery_module::get_discovery_by_name_path(atframework::atapp::app &app,
+                                                                                    const std::string &path) {
+  return LOG_WRAPPER_FWAPI_FORMAT("{}{}/{}-{}", path, ETCD_MODULE_BY_NAME_DIR, app.get_app_name(), app.get_id());
+}
+
+LIBATAPP_MACRO_API std::string service_discovery_module::get_topology_path(atframework::atapp::app &app,
+                                                                           const std::string &path) {
+  return LOG_WRAPPER_FWAPI_FORMAT("{}{}/{}-{}", path, ETCD_MODULE_TOPOLOGY_DIR, app.get_app_name(), app.get_id());
+}
+
+LIBATAPP_MACRO_API std::string service_discovery_module::get_discovery_by_id_watcher_path(
+    ATFW_EXPLICIT_UNUSED_ATTR atframework::atapp::app &app, const std::string &path) {
+  return LOG_WRAPPER_FWAPI_FORMAT("{}{}", path, ETCD_MODULE_BY_ID_DIR);
+}
+
+LIBATAPP_MACRO_API std::string service_discovery_module::get_discovery_by_name_watcher_path(
+    ATFW_EXPLICIT_UNUSED_ATTR atframework::atapp::app &app, const std::string &path) {
+  return LOG_WRAPPER_FWAPI_FORMAT("{}{}", path, ETCD_MODULE_BY_NAME_DIR);
+}
+
+LIBATAPP_MACRO_API std::string service_discovery_module::get_topology_watcher_path(
+    ATFW_EXPLICIT_UNUSED_ATTR atframework::atapp::app &app, const std::string &path) {
+  return LOG_WRAPPER_FWAPI_FORMAT("{}{}", path, ETCD_MODULE_TOPOLOGY_DIR);
+}
+
+LIBATAPP_MACRO_API int service_discovery_module::init_discovery_watcher_by_id(
+    ATFW_EXPLICIT_UNUSED_ATTR atframework::atapp::app &app, service_discovery_cluster_context &context) {
+  if (!context.data_->internal_discovery_watcher_by_id_) {
+    std::string watch_path =
+        LOG_WRAPPER_FWAPI_FORMAT("{}{}", context.etcd_module_.get_configure_path(), ETCD_MODULE_BY_ID_DIR);
+
+    context.data_->internal_discovery_watcher_by_id_ =
+        atapp::etcd_watcher::create(context.etcd_module_.get_etcd_cluster(), watch_path, "+1");
+    if (!context.data_->internal_discovery_watcher_by_id_) {
+      LIBATAPP_MACRO_ETCD_CLUSTER_LOG_ERROR(context.etcd_module_.get_etcd_cluster(),
+                                            "create etcd_watcher by_id failed.");
+      return EN_ATBUS_ERR_MALLOC;
+    }
+
+    context.data_->internal_discovery_watcher_by_id_->set_conf_from_protobuf(
+        context.etcd_module_.get_configure().watcher());
+    context.etcd_module_.get_etcd_cluster().add_watcher(context.data_->internal_discovery_watcher_by_id_);
+    LIBATAPP_MACRO_ETCD_CLUSTER_LOG_INFO(context.etcd_module_.get_etcd_cluster(),
+                                         "create etcd_watcher for by_id index {} success", watch_path);
+
+    context.data_->internal_discovery_watcher_by_id_->set_evt_handle(discovery_watcher_callback_list_wrapper_t(
+        *app.get_service_discovery_module(), context, context.data_->discovery_watcher_callback_lock_,
+        context.data_->discovery_watcher_by_id_callbacks_,
+        ++context.data_->discovery_watcher_snapshot_index_allocator_));
+  }
+  return 0;
+}
+
+LIBATAPP_MACRO_API int service_discovery_module::init_discovery_watcher_by_name(
+    ATFW_EXPLICIT_UNUSED_ATTR atframework::atapp::app &app, service_discovery_cluster_context &context) {
+  if (!context.data_->internal_discovery_watcher_by_name_) {
+    // generate watch data
+    std::string watch_path =
+        LOG_WRAPPER_FWAPI_FORMAT("{}{}", context.etcd_module_.get_configure_path(), ETCD_MODULE_BY_NAME_DIR);
+
+    context.data_->internal_discovery_watcher_by_name_ =
+        atapp::etcd_watcher::create(context.etcd_module_.get_etcd_cluster(), watch_path, "+1");
+    if (!context.data_->internal_discovery_watcher_by_name_) {
+      LIBATAPP_MACRO_ETCD_CLUSTER_LOG_ERROR(context.etcd_module_.get_etcd_cluster(),
+                                            "create etcd_watcher by_name failed.");
+      return EN_ATBUS_ERR_MALLOC;
+    }
+
+    context.data_->internal_discovery_watcher_by_name_->set_conf_from_protobuf(
+        context.etcd_module_.get_configure().watcher());
+    context.etcd_module_.get_etcd_cluster().add_watcher(context.data_->internal_discovery_watcher_by_name_);
+    LIBATAPP_MACRO_ETCD_CLUSTER_LOG_INFO(context.etcd_module_.get_etcd_cluster(),
+                                         "create etcd_watcher for by_name index {} success", watch_path);
+
+    context.data_->internal_discovery_watcher_by_name_->set_evt_handle(discovery_watcher_callback_list_wrapper_t(
+        *app.get_service_discovery_module(), context, context.data_->discovery_watcher_callback_lock_,
+        context.data_->discovery_watcher_by_name_callbacks_,
+        ++context.data_->discovery_watcher_snapshot_index_allocator_));
+  }
+  return 0;
+}
+
+LIBATAPP_MACRO_API int service_discovery_module::init_topology_watcher(
+    ATFW_EXPLICIT_UNUSED_ATTR atframework::atapp::app &app, service_discovery_cluster_context &context) {
+  if (!context.data_->internal_topology_watcher_) {
+    // generate watch data
+    std::string watch_path =
+        LOG_WRAPPER_FWAPI_FORMAT("{}{}", context.etcd_module_.get_configure_path(), ETCD_MODULE_TOPOLOGY_DIR);
+
+    context.data_->internal_topology_watcher_ =
+        atapp::etcd_watcher::create(context.etcd_module_.get_etcd_cluster(), watch_path, "+1");
+    if (!context.data_->internal_topology_watcher_) {
+      LIBATAPP_MACRO_ETCD_CLUSTER_LOG_ERROR(context.etcd_module_.get_etcd_cluster(),
+                                            "create etcd_watcher topology failed.");
+      return EN_ATBUS_ERR_MALLOC;
+    }
+
+    context.data_->internal_topology_watcher_->set_conf_from_protobuf(context.etcd_module_.get_configure().watcher());
+    context.etcd_module_.get_etcd_cluster().add_watcher(context.data_->internal_topology_watcher_);
+    LIBATAPP_MACRO_ETCD_CLUSTER_LOG_INFO(context.etcd_module_.get_etcd_cluster(),
+                                         "create etcd_watcher for topology index {} success", watch_path);
+
+    context.data_->internal_topology_watcher_->set_evt_handle(topology_watcher_callback_list_wrapper_t(
+        *app.get_service_discovery_module(), context, context.data_->topology_watcher_callback_lock_,
+        context.data_->topology_watcher_callbacks_, ++context.data_->topology_watcher_snapshot_index_allocator_));
+  }
+  return 0;
+}
+
+LIBATAPP_MACRO_API int service_discovery_module::service_discovery_cluster_context::init(
+    atframework::atapp::app &app, const atapp::protocol::atapp_etcd &conf,
+    const atapp::protocol::atapp_log *ATFW_UTIL_MACRO_NULLABLE log_conf) {
+  return etcd_module_.init(app, conf, log_conf);
+}
+
+LIBATAPP_MACRO_API int service_discovery_module::service_discovery_cluster_context::reload(
+    const atapp::protocol::atapp_etcd &conf, const atapp::protocol::atapp_log *ATFW_UTIL_MACRO_NULLABLE log_conf) {
+  return etcd_module_.reload(conf, log_conf);
+}
+
+LIBATAPP_MACRO_API int service_discovery_module::service_discovery_cluster_context::stop() {
+  reset_internal_watchers_and_keepalives();
+  return etcd_module_.stop();
+}
+
+LIBATAPP_MACRO_API void service_discovery_module::service_discovery_cluster_context::tick() { etcd_module_.tick(); }
+
+LIBATAPP_MACRO_API etcd_module &service_discovery_module::service_discovery_cluster_context::get_etcd_module() {
+  return etcd_module_;
+}
+
+LIBATAPP_MACRO_API const etcd_module &service_discovery_module::service_discovery_cluster_context::get_etcd_module()
+    const {
+  return etcd_module_;
+}
+
+LIBATAPP_MACRO_API bool
+service_discovery_module::service_discovery_cluster_context::check_keepalive_actor_start_success() {
+  const std::list<etcd_keepalive::ptr_t> *keepalive_actors[] = {&data_->internal_discovery_keepalive_actors_,
+                                                                &data_->internal_topology_keepalive_actors_};
+
+  return etcd_module_.check_keepalive_actor_start_success(gsl::make_span(keepalive_actors));
+}
+
+LIBATAPP_MACRO_API void
+service_discovery_module::service_discovery_cluster_context::add_discovery_watcher_by_id_callback(
+    const discovery_watcher_list_callback_t &fn) {
+  if (fn) {
+    std::lock_guard<std::recursive_mutex> lock_guard{data_->discovery_watcher_callback_lock_};
+    data_->discovery_watcher_by_id_callbacks_.push_back(fn);
+  }
+}
+
+LIBATAPP_MACRO_API void
+service_discovery_module::service_discovery_cluster_context::add_discovery_watcher_by_name_callback(
+    const discovery_watcher_list_callback_t &fn) {
+  if (fn) {
+    std::lock_guard<std::recursive_mutex> lock_guard{data_->discovery_watcher_callback_lock_};
+    data_->discovery_watcher_by_name_callbacks_.push_back(fn);
+  }
+}
+
+LIBATAPP_MACRO_API void service_discovery_module::service_discovery_cluster_context::add_topology_watcher_callback(
+    const topology_watcher_list_callback_t &fn) {
+  if (fn) {
+    std::lock_guard<std::recursive_mutex> lock_guard{data_->topology_watcher_callback_lock_};
+    data_->topology_watcher_callbacks_.push_back(fn);
+  }
+}
+
+LIBATAPP_MACRO_API int service_discovery_module::add_discovery_watcher_by_id_callback(
+    const discovery_watcher_list_callback_t &fn) {
+  int ret = init_discovery_watcher_by_id(*get_app(), cluster_context_);
+  if (ret < 0) {
+    return ret;
+  }
+  cluster_context_.add_discovery_watcher_by_id_callback(fn);
+  return 0;
+}
+
+LIBATAPP_MACRO_API int service_discovery_module::add_discovery_watcher_by_name_callback(
+    const discovery_watcher_list_callback_t &fn) {
+  int ret = init_discovery_watcher_by_name(*get_app(), cluster_context_);
+  if (ret < 0) {
+    return ret;
+  }
+  cluster_context_.add_discovery_watcher_by_name_callback(fn);
+  return 0;
+}
+
+LIBATAPP_MACRO_API int service_discovery_module::add_topology_watcher_callback(
+    const topology_watcher_list_callback_t &fn) {
+  int ret = init_topology_watcher(*get_app(), cluster_context_);
+  if (ret < 0) {
+    return ret;
+  }
+  cluster_context_.add_topology_watcher_callback(fn);
+  return 0;
+}
+
+LIBATAPP_MACRO_API const ::atframework::atapp::etcd_cluster &service_discovery_module::get_raw_etcd_ctx() const {
+  return cluster_context_.get_etcd_module().get_etcd_cluster();
+}
+LIBATAPP_MACRO_API ::atframework::atapp::etcd_cluster &service_discovery_module::get_raw_etcd_ctx() {
+  return cluster_context_.get_etcd_module().get_etcd_cluster();
+}
+
+LIBATAPP_MACRO_API const ::atframework::atapp::etcd_response_header &
+service_discovery_module::get_last_etcd_event_topology_header() const noexcept {
+  return cluster_context_.data_->last_etcd_event_topology_header_;
+}
+
+LIBATAPP_MACRO_API const ::atframework::atapp::etcd_response_header &
+service_discovery_module::get_last_etcd_event_discovery_header() const noexcept {
+  return cluster_context_.data_->last_etcd_event_discovery_header_;
+}
+
+LIBATAPP_MACRO_API const atapp::protocol::atapp_etcd &service_discovery_module::get_configure() const {
+  return get_app()->get_origin_configure().etcd();
+}
+
+LIBATAPP_MACRO_API const std::string &service_discovery_module::get_configure_path() {
+  return cluster_context_.get_etcd_module().get_configure_path();
+}
+
+LIBATAPP_MACRO_API atapp::etcd_keepalive::ptr_t service_discovery_module::add_keepalive_actor(
+    atframework::atapp::app &app, service_discovery_cluster_context &context, std::string &val,
+    const std::string &node_path) {
+  atapp::etcd_keepalive::ptr_t ret;
+
+  if (val.empty()) {
+    node_info_t ni;
+    app.pack(ni.node_discovery);
+    pack(ni, val);
+  }
+
+  ret = atapp::etcd_keepalive::create(context.etcd_module_.get_etcd_cluster(), node_path);
+  if (!ret) {
+    LIBATAPP_MACRO_ETCD_CLUSTER_LOG_ERROR(context.etcd_module_.get_etcd_cluster(), "create etcd_keepalive failed.");
+    return ret;
+  }
+
+  ret->set_checker(val);
+  ret->set_value(val);
+
+  if (!context.etcd_module_.get_etcd_cluster().add_keepalive(ret)) {
+    ret.reset();
+  }
+
+  return ret;
+}
+
+LIBATAPP_MACRO_API atapp::etcd_keepalive::ptr_t service_discovery_module::add_keepalive_actor(
+    atframework::atapp::app &app, std::string &val, const std::string &node_path) {
+  return add_keepalive_actor(app, cluster_context_, val, node_path);
+}
+
+LIBATAPP_MACRO_API bool service_discovery_module::remove_keepalive_actor(
+    ATFW_EXPLICIT_UNUSED_ATTR atframework::atapp::app &app, service_discovery_cluster_context &context,
+    const atapp::etcd_keepalive::ptr_t &keepalive) {
+  if (!keepalive) {
+    return false;
+  }
+
+  return context.etcd_module_.get_etcd_cluster().remove_keepalive(keepalive);
+}
+
+LIBATAPP_MACRO_API bool service_discovery_module::remove_keepalive_actor(
+    atframework::atapp::app &app, const atapp::etcd_keepalive::ptr_t &keepalive) {
+  std::list<etcd_keepalive::ptr_t> *keepalive_actors[] = {&cluster_context_.data_->internal_discovery_keepalive_actors_,
+                                                          &cluster_context_.data_->internal_topology_keepalive_actors_};
+
+  for (auto *keepalive_actor_list : keepalive_actors) {
+    std::list<etcd_keepalive::ptr_t>::iterator internal_iter =
+        std::find(keepalive_actor_list->begin(), keepalive_actor_list->end(), keepalive);
+    if (internal_iter != keepalive_actor_list->end()) {
+      keepalive_actor_list->erase(internal_iter);
+    }
+  }
+  return remove_keepalive_actor(app, cluster_context_, keepalive);
+}
+
+LIBATAPP_MACRO_API service_discovery_module::node_event_callback_handle_t
+service_discovery_module::add_on_node_discovery_event(const node_event_callback_t &fn) {
+  std::lock_guard<std::recursive_mutex> lock_guard{node_event_lock_};
+  if (!fn) {
+    return node_event_callbacks_.end();
+  }
+
+  return node_event_callbacks_.insert(node_event_callbacks_.end(), fn);
+}
+
+LIBATAPP_MACRO_API void service_discovery_module::remove_on_node_event(node_event_callback_handle_t &handle) {
+  std::lock_guard<std::recursive_mutex> lock_guard{node_event_lock_};
+  if (handle == node_event_callbacks_.end()) {
+    return;
+  }
+
+  node_event_callbacks_.erase(handle);
+  handle = node_event_callbacks_.end();
+}
+
+LIBATAPP_MACRO_API service_discovery_module::topology_info_event_callback_handle_t
+service_discovery_module::add_on_topology_info_event(const topology_info_event_callback_t &fn) {
+  std::lock_guard<std::recursive_mutex> lock_guard{topology_info_event_lock_};
+  if (!fn) {
+    return topology_info_event_callbacks_.end();
+  }
+
+  return topology_info_event_callbacks_.insert(topology_info_event_callbacks_.end(), fn);
+}
+
+LIBATAPP_MACRO_API void service_discovery_module::remove_on_topology_info_event(
+    topology_info_event_callback_handle_t &handle) {
+  std::lock_guard<std::recursive_mutex> lock_guard{topology_info_event_lock_};
+  if (handle == topology_info_event_callbacks_.end()) {
+    return;
+  }
+
+  topology_info_event_callbacks_.erase(handle);
+  handle = topology_info_event_callbacks_.end();
+}
+
+LIBATAPP_MACRO_API etcd_discovery_set &service_discovery_module::get_global_discovery() noexcept {
+  return global_discovery_;
+}
+
+LIBATAPP_MACRO_API const etcd_discovery_set &service_discovery_module::get_global_discovery() const noexcept {
+  return global_discovery_;
+}
+
+LIBATAPP_MACRO_API const std::unordered_map<uint64_t, service_discovery_module::topology_storage_t> &
+service_discovery_module::get_topology_info_set() const noexcept {
+  return internal_topology_info_set_;
+}
+
+LIBATAPP_MACRO_API bool service_discovery_module::has_discovery_snapshot() const noexcept {
+  return !cluster_context_.data_->discovery_watcher_snapshot_index_.empty();
+}
+
+LIBATAPP_MACRO_API service_discovery_module::discovery_snapshot_event_callback_handle_t
+service_discovery_module::add_on_load_discovery_snapshot(const discovery_snapshot_event_callback_t &fn) {
+  if (!fn) {
+    return discovery_on_load_snapshot_callbacks_.end();
+  }
+
+  return discovery_on_load_snapshot_callbacks_.insert(discovery_on_load_snapshot_callbacks_.end(), fn);
+}
+
+LIBATAPP_MACRO_API void service_discovery_module::remove_on_load_discovery_snapshot(
+    discovery_snapshot_event_callback_handle_t &handle) {
+  if (handle == discovery_on_load_snapshot_callbacks_.end()) {
+    return;
+  }
+
+  discovery_on_load_snapshot_callbacks_.erase(handle);
+  handle = discovery_on_load_snapshot_callbacks_.end();
+}
+
+LIBATAPP_MACRO_API service_discovery_module::discovery_snapshot_event_callback_handle_t
+service_discovery_module::add_on_discovery_snapshot_loaded(const discovery_snapshot_event_callback_t &fn) {
+  if (!fn) {
+    return discovery_on_snapshot_loaded_callbacks_.end();
+  }
+
+  return discovery_on_snapshot_loaded_callbacks_.insert(discovery_on_snapshot_loaded_callbacks_.end(), fn);
+}
+
+LIBATAPP_MACRO_API void service_discovery_module::remove_on_discovery_snapshot_loaded(
+    discovery_snapshot_event_callback_handle_t &handle) {
+  if (handle == discovery_on_snapshot_loaded_callbacks_.end()) {
+    return;
+  }
+
+  discovery_on_snapshot_loaded_callbacks_.erase(handle);
+  handle = discovery_on_snapshot_loaded_callbacks_.end();
+}
+
+LIBATAPP_MACRO_API bool service_discovery_module::has_topology_snapshot() const noexcept {
+  return !cluster_context_.data_->topology_watcher_snapshot_index_.empty();
+}
+
+LIBATAPP_MACRO_API service_discovery_module::topology_snapshot_event_callback_handle_t
+service_discovery_module::add_on_load_topology_snapshot(const topology_snapshot_event_callback_t &fn) {
+  if (!fn) {
+    return topology_on_load_snapshot_callbacks_.end();
+  }
+
+  return topology_on_load_snapshot_callbacks_.insert(topology_on_load_snapshot_callbacks_.end(), fn);
+}
+
+LIBATAPP_MACRO_API void service_discovery_module::remove_on_load_topology_snapshot(
+    topology_snapshot_event_callback_handle_t &handle) {
+  if (handle == topology_on_load_snapshot_callbacks_.end()) {
+    return;
+  }
+
+  topology_on_load_snapshot_callbacks_.erase(handle);
+  handle = topology_on_load_snapshot_callbacks_.end();
+}
+
+LIBATAPP_MACRO_API service_discovery_module::topology_snapshot_event_callback_handle_t
+service_discovery_module::add_on_topology_snapshot_loaded(const topology_snapshot_event_callback_t &fn) {
+  if (!fn) {
+    return topology_on_snapshot_loaded_callbacks_.end();
+  }
+
+  return topology_on_snapshot_loaded_callbacks_.insert(topology_on_snapshot_loaded_callbacks_.end(), fn);
+}
+
+LIBATAPP_MACRO_API void service_discovery_module::remove_on_topology_snapshot_loaded(
+    topology_snapshot_event_callback_handle_t &handle) {
+  if (handle == topology_on_snapshot_loaded_callbacks_.end()) {
+    return;
+  }
+
+  topology_on_snapshot_loaded_callbacks_.erase(handle);
+  handle = topology_on_snapshot_loaded_callbacks_.end();
+}
+
+LIBATAPP_MACRO_API etcd_watcher::watch_event_fn_t_ptr
+service_discovery_module::create_discovery_watcher_callback_list_wrapper(service_discovery_cluster_context &context) {
+  return std::make_unique<etcd_watcher::watch_event_fn_t>(discovery_watcher_callback_list_wrapper_t(
+      *this, context, ++context.data_->discovery_watcher_snapshot_index_allocator_));
+}
+LIBATAPP_MACRO_API etcd_watcher::watch_event_fn_t_ptr
+service_discovery_module::create_topology_watcher_callback_list_wrapper(service_discovery_cluster_context &context) {
+  return std::make_unique<etcd_watcher::watch_event_fn_t>(topology_watcher_callback_list_wrapper_t(
+      *this, context, ++context.data_->topology_watcher_snapshot_index_allocator_));
+}
+
+bool service_discovery_module::unpack(node_info_t &out, const std::string &path, const std::string &json,
+                                      bool reset_data) {
+  if (reset_data) {
+    out.node_discovery.Clear();
+  }
+
+  if (json.empty()) {
+    size_t start_idx = 0;
+    size_t last_minus = 0;
+    for (size_t i = 0; i < path.size(); ++i) {
+      if (path[i] == '/' || path[i] == '\\' || path[i] == ' ' || path[i] == '\t' || path[i] == '\r' ||
+          path[i] == '\n') {
+        start_idx = i + 1;
+      } else if (path[i] == '-') {
+        last_minus = i;
+      }
+    }
+
+    // parse id from key if key is a number
+    if (start_idx < path.size()) {
+      if (last_minus + 1 < path.size() && last_minus >= start_idx) {
+        out.node_discovery.set_id(atfw::util::string::to_int<uint64_t>(path.c_str() + last_minus + 1));
+        out.node_discovery.set_name(path.substr(start_idx, last_minus - start_idx));
+      } else {
+        // old mode, only id on last segment
+        out.node_discovery.set_id(atfw::util::string::to_int<uint64_t>(&path[start_idx]));
+      }
+    }
+    return false;
+  }
+
+  ATBUS_MACRO_PROTOBUF_NAMESPACE_ID::util::JsonParseOptions options;
+  options.ignore_unknown_fields = true;
+
+  if (!ATBUS_MACRO_PROTOBUF_NAMESPACE_ID::util::JsonStringToMessage(json, &out.node_discovery, options).ok()) {
+    return false;
+  }
+
+  return true;
+}
+
+void service_discovery_module::pack(const node_info_t &src, std::string &json) {
+  ATBUS_MACRO_PROTOBUF_NAMESPACE_ID::util::JsonPrintOptions options;
+  options.add_whitespace = false;
+  options.always_print_enums_as_ints = true;
+  options.preserve_proto_field_names = true;
+  options.unquote_int64_if_possible = true;
+  if (!ATBUS_MACRO_PROTOBUF_NAMESPACE_ID::util::MessageToJsonString(src.node_discovery, &json, options).ok()) {
+    FWLOGERROR("service_discovery_module pack message to json failed");
+  }
+}
+
+bool service_discovery_module::unpack(topology_info_t &out, const std::string &path, const std::string &json,
+                                      bool reset_data) {
+  if (reset_data && out.storage.info) {
+    out.storage.info->Clear();
+  }
+  if (!out.storage.info) {
+    out.storage.info = atfw::util::memory::make_strong_rc<atapp::protocol::atapp_topology_info>();
+  }
+
+  if (json.empty()) {
+    size_t start_idx = 0;
+    size_t last_minus = 0;
+    for (size_t i = 0; i < path.size(); ++i) {
+      if (path[i] == '/' || path[i] == '\\' || path[i] == ' ' || path[i] == '\t' || path[i] == '\r' ||
+          path[i] == '\n') {
+        start_idx = i + 1;
+      } else if (path[i] == '-') {
+        last_minus = i;
+      }
+    }
+
+    // parse id from key if key is a number
+    if (start_idx < path.size()) {
+      if (last_minus + 1 < path.size() && last_minus >= start_idx) {
+        out.storage.info->set_id(atfw::util::string::to_int<uint64_t>(path.c_str() + last_minus + 1));
+        out.storage.info->set_name(path.substr(start_idx, last_minus - start_idx));
+      } else {
+        // old mode, only id on last segment
+        out.storage.info->set_id(atfw::util::string::to_int<uint64_t>(&path[start_idx]));
+      }
+    }
+    return false;
+  }
+
+  ATBUS_MACRO_PROTOBUF_NAMESPACE_ID::util::JsonParseOptions options;
+  options.ignore_unknown_fields = true;
+
+  if (!ATBUS_MACRO_PROTOBUF_NAMESPACE_ID::util::JsonStringToMessage(json, out.storage.info.get(), options).ok()) {
+    return false;
+  }
+
+  return true;
+}
+
+void service_discovery_module::pack(const atapp::protocol::atapp_topology_info &src, std::string &json) {
+  ATBUS_MACRO_PROTOBUF_NAMESPACE_ID::util::JsonPrintOptions options;
+  options.add_whitespace = false;
+  options.always_print_enums_as_ints = true;
+  options.preserve_proto_field_names = true;
+  options.unquote_int64_if_possible = true;
+  if (!ATBUS_MACRO_PROTOBUF_NAMESPACE_ID::util::MessageToJsonString(src, &json, options).ok()) {
+    FWLOGERROR("service_discovery_module pack message to json failed");
+  }
+}
+
+namespace {
+static void _collect_old_nodes(service_discovery_module &mod, etcd_discovery_set::node_by_name_type &old_names,
+                               etcd_discovery_set::node_by_id_type &old_ids) {
+  old_ids.reserve(mod.get_global_discovery().get_sorted_nodes().size());
+  old_names.reserve(mod.get_global_discovery().get_sorted_nodes().size());
+  for (const auto &node : mod.get_global_discovery().get_sorted_nodes()) {
+    if (!node) {
+      continue;
+    }
+    if (0 != node->get_discovery_info().id()) {
+      old_ids[node->get_discovery_info().id()] = node;
+    } else if (!node->get_discovery_info().name().empty()) {
+      old_names[node->get_discovery_info().name()] = node;
+    }
+  }
+}
+
+static void _remove_old_node_index(const atapp::protocol::atapp_discovery &node_discovery,
+                                   etcd_discovery_set::node_by_name_type &old_names,
+                                   etcd_discovery_set::node_by_id_type &old_ids) {
+  if (0 != node_discovery.id()) {
+    old_ids.erase(node_discovery.id());
+  }
+  if (!node_discovery.name().empty()) {
+    old_names.erase(node_discovery.name());
+  }
+}
+}  // namespace
+
+void service_discovery_module::watcher_internal_access_t::cleanup_old_nodes(
+    service_discovery_module &mod, service_discovery_cluster_context &ctx,
+    etcd_discovery_set::node_by_name_type &old_names, etcd_discovery_set::node_by_id_type &old_ids) {
+  for (auto &node : old_names) {
+    if (node.second->get_context_ptr() != reinterpret_cast<uintptr_t>(&ctx)) {
+      continue;
+    }
+    service_discovery_module::node_info_t evt_node;
+    evt_node.action = service_discovery_module::node_action_t::kDelete;
+    evt_node.context_ptr = reinterpret_cast<uintptr_t>(&ctx);
+    node.second->copy_key_to(evt_node.node_discovery);
+    mod.update_internal_watcher_event(evt_node, node.second->get_version());
+  }
+
+  for (auto &node : old_ids) {
+    if (node.second->get_context_ptr() != reinterpret_cast<uintptr_t>(&ctx)) {
+      continue;
+    }
+    service_discovery_module::node_info_t evt_node;
+    evt_node.action = service_discovery_module::node_action_t::kDelete;
+    evt_node.context_ptr = reinterpret_cast<uintptr_t>(&ctx);
+    node.second->copy_key_to(evt_node.node_discovery);
+    mod.update_internal_watcher_event(evt_node, node.second->get_version());
+  }
+}
+
+namespace {
+static void _collect_old_topology_peers(
+    service_discovery_module &mod,
+    std::unordered_map<uint64_t, service_discovery_module::topology_storage_t> &old_ids) {
+  old_ids.reserve(mod.get_topology_info_set().size());
+  old_ids = mod.get_topology_info_set();
+}
+
+static void _remove_old_topology_peer_index(
+    const atapp::protocol::atapp_topology_info &topology_info,
+    std::unordered_map<uint64_t, service_discovery_module::topology_storage_t> &old_ids) {
+  if (0 != topology_info.id()) {
+    old_ids.erase(topology_info.id());
+  }
+}
+}  // namespace
+
+void service_discovery_module::watcher_internal_access_t::cleanup_old_topology_peers(
+    service_discovery_module &mod, service_discovery_cluster_context &ctx,
+    std::unordered_map<uint64_t, service_discovery_module::topology_storage_t> &old_ids) {
+  for (auto &id : old_ids) {
+    if (id.second.context_ptr != reinterpret_cast<uintptr_t>(&ctx)) {
+      continue;
+    }
+    service_discovery_module::topology_info_t evt_node;
+    evt_node.action = service_discovery_module::topology_action_t::kDelete;
+    evt_node.storage = id.second;
+    mod.update_internal_watcher_event(evt_node);
+  }
+}
+
+service_discovery_module::discovery_watcher_callback_list_wrapper_t::discovery_watcher_callback_list_wrapper_t(
+    service_discovery_module &m, service_discovery_cluster_context &c, int64_t index)
+    : mod(&m),
+      ctx(&c),
+      callback_lock(nullptr),
+      callbacks(nullptr),
+      snapshot_index(index),
+      has_insert_snapshot_index(false) {}
+
+service_discovery_module::discovery_watcher_callback_list_wrapper_t::discovery_watcher_callback_list_wrapper_t(
+    service_discovery_module &m, service_discovery_cluster_context &c, std::recursive_mutex &lock,
+    std::list<discovery_watcher_list_callback_t> &cbks, int64_t index)
+    : mod(&m),
+      ctx(&c),
+      callback_lock(&lock),
+      callbacks(&cbks),
+      snapshot_index(index),
+      has_insert_snapshot_index(false) {}
+
+service_discovery_module::discovery_watcher_callback_list_wrapper_t::~discovery_watcher_callback_list_wrapper_t() {
+  if (nullptr != ctx && 0 != snapshot_index && has_insert_snapshot_index) {
+    ctx->data_->discovery_watcher_snapshot_index_.erase(snapshot_index);
+  }
+}
+
+void service_discovery_module::discovery_watcher_callback_list_wrapper_t::operator()(
+    const ::atframework::atapp::etcd_response_header &header,
+    const ::atframework::atapp::etcd_watcher::response_t &body) {
+  if (nullptr == mod) {
+    return;
+  }
+  ctx->data_->last_etcd_event_discovery_header_ = header;
+
+  bool enable_snapshot = body.snapshot && 0 != snapshot_index;
+  if (enable_snapshot) {
+    if (!has_insert_snapshot_index) {
+      ctx->data_->discovery_watcher_snapshot_index_.insert(snapshot_index);
+      has_insert_snapshot_index = true;
+    }
+
+    // We just accept the earliest watcher as snapshot notifier.
+    // So just enable by_id or by_name when initializing and they will has the smallest index.
+    if (!ctx->data_->discovery_watcher_snapshot_index_.empty() &&
+        *ctx->data_->discovery_watcher_snapshot_index_.begin() != snapshot_index) {
+      enable_snapshot = false;
+    }
+  }
+
+  etcd_discovery_set::node_by_name_type old_names;
+  etcd_discovery_set::node_by_id_type old_ids;
+  if (enable_snapshot) {
+    _collect_old_nodes(*mod, old_names, old_ids);
+
+    for (auto iter = mod->discovery_on_load_snapshot_callbacks_.begin();
+         iter != mod->discovery_on_load_snapshot_callbacks_.end();) {
+      auto copy_iter = iter;
+      ++iter;
+      if (*copy_iter) {
+        (*copy_iter)(*mod);
+      }
+    }
+  }
+
+  // decode data
+  for (size_t i = 0; i < body.events.size(); ++i) {
+    const ::atframework::atapp::etcd_watcher::event_t &evt_data = body.events[i];
+    node_info_t node;
+    node.context_ptr = reinterpret_cast<uintptr_t>(ctx);
+    etcd_discovery_node::node_version current_node_version;
+
+    unpack(node, evt_data.kv.key.empty() ? evt_data.prev_kv.key : evt_data.kv.key,
+           evt_data.kv.value.empty() ? evt_data.prev_kv.value : evt_data.kv.value, true);
+    current_node_version.create_revision = std::max(evt_data.prev_kv.create_revision, evt_data.kv.create_revision);
+    current_node_version.modify_revision = std::max(evt_data.prev_kv.mod_revision, evt_data.kv.mod_revision);
+    current_node_version.version = std::max(evt_data.prev_kv.version, evt_data.kv.version);
+
+    if (node.node_discovery.id() == 0 && node.node_discovery.name().empty()) {
+      continue;
+    }
+
+    if (enable_snapshot) {
+      _remove_old_node_index(node.node_discovery, old_names, old_ids);
+    }
+
+    if (evt_data.evt_type == ::atframework::atapp::etcd_watch_event::kDelete) {
+      node.action = node_action_t::kDelete;
+    } else {
+      node.action = node_action_t::kPut;
+    }
+
+    mod->update_internal_watcher_event(node, current_node_version);
+
+    if (nullptr == callbacks || nullptr == callback_lock) {
+      continue;
+    }
+
+    std::lock_guard<std::recursive_mutex> lock_guard{*callback_lock};
+    if (callbacks->empty()) {
+      continue;
+    }
+
+    discovery_watcher_sender_list_t sender(*mod, header, body, evt_data, node);
+    for (std::list<discovery_watcher_list_callback_t>::iterator iter = callbacks->begin(); iter != callbacks->end();
+         ++iter) {
+      if (*iter) {
+        (*iter)(std::ref(sender));
+      }
+    }
+  }
+
+  // cleanup old nodes when receive snapshot response
+  if (enable_snapshot) {
+    service_discovery_module::watcher_internal_access_t::cleanup_old_nodes(*mod, *ctx, old_names, old_ids);
+
+    for (auto iter = mod->discovery_on_snapshot_loaded_callbacks_.begin();
+         iter != mod->discovery_on_snapshot_loaded_callbacks_.end();) {
+      auto copy_iter = iter;
+      ++iter;
+      if (*copy_iter) {
+        (*copy_iter)(*mod);
+      }
+    }
+  }
+}
+
+service_discovery_module::topology_watcher_callback_list_wrapper_t::topology_watcher_callback_list_wrapper_t(
+    service_discovery_module &m, service_discovery_cluster_context &c, int64_t index)
+    : mod(&m),
+      ctx(&c),
+      callback_lock(nullptr),
+      callbacks(nullptr),
+      snapshot_index(index),
+      has_insert_snapshot_index(false) {}
+
+service_discovery_module::topology_watcher_callback_list_wrapper_t::topology_watcher_callback_list_wrapper_t(
+    service_discovery_module &m, service_discovery_cluster_context &c, std::recursive_mutex &lock,
+    std::list<topology_watcher_list_callback_t> &cbks, int64_t index)
+    : mod(&m),
+      ctx(&c),
+      callback_lock(&lock),
+      callbacks(&cbks),
+      snapshot_index(index),
+      has_insert_snapshot_index(false) {}
+
+service_discovery_module::topology_watcher_callback_list_wrapper_t::~topology_watcher_callback_list_wrapper_t() {
+  if (nullptr != ctx && 0 != snapshot_index && has_insert_snapshot_index) {
+    ctx->data_->topology_watcher_snapshot_index_.erase(snapshot_index);
+  }
+}
+
+void service_discovery_module::topology_watcher_callback_list_wrapper_t::operator()(
+    const ::atframework::atapp::etcd_response_header &header,
+    const ::atframework::atapp::etcd_watcher::response_t &body) {
+  if (nullptr == mod) {
+    return;
+  }
+  ctx->data_->last_etcd_event_topology_header_ = header;
+
+  bool enable_snapshot = body.snapshot && 0 != snapshot_index;
+  if (enable_snapshot) {
+    if (!has_insert_snapshot_index) {
+      ctx->data_->topology_watcher_snapshot_index_.insert(snapshot_index);
+      has_insert_snapshot_index = true;
+    }
+
+    // We just accept the earliest watcher as snapshot notifier.
+    // So just enable by_id or by_name when initializing and they will has the smallest index.
+    if (!ctx->data_->topology_watcher_snapshot_index_.empty() &&
+        *ctx->data_->topology_watcher_snapshot_index_.begin() != snapshot_index) {
+      enable_snapshot = false;
+    }
+  }
+
+  std::unordered_map<uint64_t, topology_storage_t> old_ids;
+  if (enable_snapshot) {
+    _collect_old_topology_peers(*mod, old_ids);
+
+    for (auto iter = mod->topology_on_load_snapshot_callbacks_.begin();
+         iter != mod->topology_on_load_snapshot_callbacks_.end();) {
+      auto copy_iter = iter;
+      ++iter;
+      if (*copy_iter) {
+        (*copy_iter)(*mod);
+      }
+    }
+  }
+
+  // decode data
+  for (size_t i = 0; i < body.events.size(); ++i) {
+    const ::atframework::atapp::etcd_watcher::event_t &evt_data = body.events[i];
+    topology_info_t topology_info;
+    topology_info.storage.context_ptr = reinterpret_cast<uintptr_t>(ctx);
+
+    unpack(topology_info, evt_data.kv.key.empty() ? evt_data.prev_kv.key : evt_data.kv.key,
+           evt_data.kv.value.empty() ? evt_data.prev_kv.value : evt_data.kv.value, true);
+    topology_info.storage.version.create_revision =
+        std::max(evt_data.prev_kv.create_revision, evt_data.kv.create_revision);
+    topology_info.storage.version.modify_revision = std::max(evt_data.prev_kv.mod_revision, evt_data.kv.mod_revision);
+    topology_info.storage.version.version = std::max(evt_data.prev_kv.version, evt_data.kv.version);
+
+    if (!topology_info.storage.info || topology_info.storage.info->id() == 0) {
+      continue;
+    }
+
+    if (enable_snapshot) {
+      _remove_old_topology_peer_index(*topology_info.storage.info, old_ids);
+    }
+    topology_info.action = evt_data.evt_type;
+
+    mod->update_internal_watcher_event(topology_info);
+
+    if (nullptr == callbacks || nullptr == callback_lock) {
+      continue;
+    }
+
+    std::lock_guard<std::recursive_mutex> lock_guard{*callback_lock};
+    if (callbacks->empty()) {
+      continue;
+    }
+
+    topology_watcher_sender_list_t sender(*mod, header, body, evt_data, topology_info);
+    for (std::list<topology_watcher_list_callback_t>::iterator iter = callbacks->begin(); iter != callbacks->end();
+         ++iter) {
+      if (*iter) {
+        (*iter)(std::ref(sender));
+      }
+    }
+  }
+
+  // cleanup old nodes when receive snapshot response
+  if (enable_snapshot) {
+    service_discovery_module::watcher_internal_access_t::cleanup_old_topology_peers(*mod, *ctx, old_ids);
+
+    for (auto iter = mod->topology_on_snapshot_loaded_callbacks_.begin();
+         iter != mod->topology_on_snapshot_loaded_callbacks_.end();) {
+      auto copy_iter = iter;
+      ++iter;
+      if (*copy_iter) {
+        (*copy_iter)(*mod);
+      }
+    }
+  }
+}
+
+bool service_discovery_module::update_internal_watcher_event(node_info_t &node,
+                                                             const etcd_discovery_node::node_version &version) {
+  etcd_discovery_node::ptr_t local_cache_by_id = global_discovery_.get_node_by_id(node.node_discovery.id());
+  etcd_discovery_node::ptr_t local_cache_by_name = global_discovery_.get_node_by_name(node.node_discovery.name());
+  etcd_discovery_node::ptr_t new_inst;
+
+  bool has_event = false;
+
+  if ATFW_UTIL_LIKELY_CONDITION (local_cache_by_id == local_cache_by_name) {
+    if (node_action_t::kDelete == node.action) {
+      if (local_cache_by_id) {
+        local_cache_by_id->update_version(version, true, node.context_ptr);
+        global_discovery_.remove_node(local_cache_by_id);
+
+        has_event = true;
+      }
+    } else {
+      if (local_cache_by_id && protobuf_equal(local_cache_by_id->get_discovery_info(), node.node_discovery) &&
+          local_cache_by_id->get_context_ptr() == node.context_ptr) {
+        local_cache_by_id->update_version(version, false, node.context_ptr);
+        return false;
+      }
+
+      if (local_cache_by_id) {
+        new_inst = local_cache_by_id;
+      } else {
+        new_inst = atfw::util::memory::make_strong_rc<etcd_discovery_node>();
+      }
+
+      new_inst->copy_from(node.node_discovery, version, node.context_ptr);
+      global_discovery_.add_node(new_inst);
+
+      has_event = true;
+    }
+  } else {
+    if (node_action_t::kDelete == node.action) {
+      if (local_cache_by_id) {
+        local_cache_by_id->update_version(version, true, node.context_ptr);
+        global_discovery_.remove_node(local_cache_by_id);
+        has_event = true;
+      }
+      if (local_cache_by_name) {
+        local_cache_by_name->update_version(version, true, node.context_ptr);
+        global_discovery_.remove_node(local_cache_by_name);
+        has_event = true;
+      }
+    } else {
+      if ((!local_cache_by_id && 0 != node.node_discovery.id()) ||
+          (!local_cache_by_name && !node.node_discovery.name().empty())) {
+        has_event = true;
+      } else if (local_cache_by_id &&
+                 (false == protobuf_equal(local_cache_by_id->get_discovery_info(), node.node_discovery) ||
+                  local_cache_by_id->get_context_ptr() != node.context_ptr)) {
+        new_inst = local_cache_by_id;
+        has_event = true;
+      } else if (local_cache_by_name &&
+                 (false == protobuf_equal(local_cache_by_name->get_discovery_info(), node.node_discovery) ||
+                  local_cache_by_name->get_context_ptr() != node.context_ptr)) {
+        new_inst = local_cache_by_name;
+        has_event = true;
+      }
+
+      if (has_event) {
+        if (!new_inst) {
+          new_inst = atfw::util::memory::make_strong_rc<etcd_discovery_node>();
+        }
+        new_inst->copy_from(node.node_discovery, version, node.context_ptr);
+
+        if (local_cache_by_id && local_cache_by_id != new_inst) {
+          local_cache_by_id->update_version(version, false, node.context_ptr);
+          global_discovery_.remove_node(local_cache_by_id);
+        }
+        if (local_cache_by_name && local_cache_by_name != new_inst) {
+          local_cache_by_name->update_version(version, false, node.context_ptr);
+          global_discovery_.remove_node(local_cache_by_name);
+        }
+
+        global_discovery_.add_node(new_inst);
+      }
+    }
+  }
+
+  // remove endpoint if got DELETE event
+  if (has_event) {
+    app *owner = get_app();
+    if (node_action_t::kDelete == node.action && nullptr != owner) {
+      if (0 != node.node_discovery.id()) {
+        owner->remove_endpoint(node.node_discovery.id());
+      }
+      if (!node.node_discovery.name().empty()) {
+        owner->remove_endpoint(node.node_discovery.name());
+      }
+    }
+
+    if (nullptr != owner) {
+      std::lock_guard<std::recursive_mutex> lock_guard{node_event_lock_};
+
+      // notify all connector discovery event
+      if (new_inst) {
+        owner->trigger_event_on_discovery_event(node.action, new_inst);
+        for (node_event_callback_list_t::iterator iter = node_event_callbacks_.begin();
+             iter != node_event_callbacks_.end(); ++iter) {
+          if (*iter) {
+            (*iter)(node.action, new_inst);
+          }
+        }
+      } else if (local_cache_by_name) {
+        owner->trigger_event_on_discovery_event(node.action, local_cache_by_name);
+        for (node_event_callback_list_t::iterator iter = node_event_callbacks_.begin();
+             iter != node_event_callbacks_.end(); ++iter) {
+          if (*iter) {
+            (*iter)(node.action, local_cache_by_name);
+          }
+        }
+      } else {
+        owner->trigger_event_on_discovery_event(node.action, local_cache_by_id);
+        for (node_event_callback_list_t::iterator iter = node_event_callbacks_.begin();
+             iter != node_event_callbacks_.end(); ++iter) {
+          if (*iter) {
+            (*iter)(node.action, local_cache_by_id);
+          }
+        }
+      }
+    }
+  }
+
+  return has_event;
+}
+
+bool service_discovery_module::update_internal_watcher_event(topology_info_t &topology_info) {
+  if (!topology_info.storage.info) {
+    return false;
+  }
+
+  atapp_topology_info_ptr_t info_ptr{};
+  if (topology_info.action == topology_action_t::kDelete) {
+    std::unordered_map<uint64_t, topology_storage_t>::iterator local_cache_iter =
+        internal_topology_info_set_.find(topology_info.storage.info->id());
+    if (local_cache_iter == internal_topology_info_set_.end()) {
+      return false;
+    }
+
+    info_ptr = local_cache_iter->second.info;
+    internal_topology_info_set_.erase(local_cache_iter);
+  } else {
+    std::unordered_map<uint64_t, topology_storage_t>::iterator local_cache_iter =
+        internal_topology_info_set_.find(topology_info.storage.info->id());
+    if (local_cache_iter != internal_topology_info_set_.end()) {
+      bool changed = topology_update_version(local_cache_iter->second, topology_info.storage.version, true,
+                                             topology_info.storage.context_ptr);
+
+      // 未变化
+      if (local_cache_iter->second.info &&
+          atapp_topology_equal(*local_cache_iter->second.info, *topology_info.storage.info)) {
+        return false;
+      }
+
+      // 版本未更新时，视为过期或乱序事件，不触发回调
+      if (!changed) {
+        return false;
+      }
+      local_cache_iter->second.info = topology_info.storage.info;
+      info_ptr = local_cache_iter->second.info;
+    } else {
+      internal_topology_info_set_[topology_info.storage.info->id()] = topology_info.storage;
+      info_ptr = topology_info.storage.info;
+    }
+  }
+
+  app *owner = get_app();
+  if (owner != nullptr) {
+    std::lock_guard<std::recursive_mutex> lock_guard{topology_info_event_lock_};
+    owner->trigger_event_on_topology_event(topology_info.action, info_ptr, topology_info.storage.version);
+
+    for (topology_info_event_callback_list_t::iterator iter = topology_info_event_callbacks_.begin();
+         iter != topology_info_event_callbacks_.end(); ++iter) {
+      if (*iter) {
+        (*iter)(topology_info.action, info_ptr, topology_info.storage.version);
+      }
+    }
+  }
+  return true;
+}
+
+void service_discovery_module::service_discovery_cluster_context::reset_internal_watchers_and_keepalives() {
+  if (data_->internal_discovery_watcher_by_name_) {
+    etcd_module_.get_etcd_cluster().remove_watcher(data_->internal_discovery_watcher_by_name_);
+    data_->internal_discovery_watcher_by_name_.reset();
+  }
+
+  if (data_->internal_discovery_watcher_by_id_) {
+    etcd_module_.get_etcd_cluster().remove_watcher(data_->internal_discovery_watcher_by_id_);
+    data_->internal_discovery_watcher_by_id_.reset();
+  }
+
+  if (data_->internal_topology_watcher_) {
+    etcd_module_.get_etcd_cluster().remove_watcher(data_->internal_topology_watcher_);
+    data_->internal_topology_watcher_.reset();
+  }
+
+  data_->internal_discovery_keepalive_actors_.clear();
+  data_->internal_topology_keepalive_actors_.clear();
+}
+
+LIBATAPP_MACRO_NAMESPACE_END
\ No newline at end of file
diff --git a/test/case/atapp_direct_connect_test.cpp b/test/case/atapp_direct_connect_test.cpp
index a879908..6e012da 100644
--- a/test/case/atapp_direct_connect_test.cpp
+++ b/test/case/atapp_direct_connect_test.cpp
@@ -8,6 +8,7 @@
 #include <atframe/atapp.h>
 #include <atframe/connectors/atapp_connector_atbus.h>
 #include <atframe/modules/etcd_module.h>
+#include <atframe/modules/service_discovery_module.h>
 #include <detail/libatbus_error.h>
 
 #include <common/file_system.h>
@@ -127,23 +128,23 @@ struct direct_three_node_apps {
     {
       atapp::protocol::atapp_discovery info;
       node1.pack(info);
-      node1_discovery->copy_from(info, atapp::etcd_discovery_node::node_version());
+      node1_discovery->copy_from(info, atapp::etcd_discovery_node::node_version(), 0);
     }
     {
       atapp::protocol::atapp_discovery info;
       node2.pack(info);
-      node2_discovery->copy_from(info, atapp::etcd_discovery_node::node_version());
+      node2_discovery->copy_from(info, atapp::etcd_discovery_node::node_version(), 0);
     }
     {
       atapp::protocol::atapp_discovery info;
       upstream.pack(info);
-      upstream_discovery->copy_from(info, atapp::etcd_discovery_node::node_version());
+      upstream_discovery->copy_from(info, atapp::etcd_discovery_node::node_version(), 0);
     }
 
     // All nodes know about all other nodes
-    auto &node1_gd = node1.get_etcd_module()->get_global_discovery();
-    auto &node2_gd = node2.get_etcd_module()->get_global_discovery();
-    auto &upstream_gd = upstream.get_etcd_module()->get_global_discovery();
+    auto &node1_gd = node1.get_service_discovery_module()->get_global_discovery();
+    auto &node2_gd = node2.get_service_discovery_module()->get_global_discovery();
+    auto &upstream_gd = upstream.get_service_discovery_module()->get_global_discovery();
 
     node1_gd.add_node(node1_discovery);
     node1_gd.add_node(node2_discovery);
@@ -165,17 +166,17 @@ struct direct_three_node_apps {
     {
       atapp::protocol::atapp_discovery info;
       node1.pack(info);
-      node1_discovery->copy_from(info, atapp::etcd_discovery_node::node_version());
+      node1_discovery->copy_from(info, atapp::etcd_discovery_node::node_version(), 0);
     }
     {
       atapp::protocol::atapp_discovery info;
       upstream.pack(info);
-      upstream_discovery->copy_from(info, atapp::etcd_discovery_node::node_version());
+      upstream_discovery->copy_from(info, atapp::etcd_discovery_node::node_version(), 0);
     }
 
-    auto &node1_gd = node1.get_etcd_module()->get_global_discovery();
-    auto &node2_gd = node2.get_etcd_module()->get_global_discovery();
-    auto &upstream_gd = upstream.get_etcd_module()->get_global_discovery();
+    auto &node1_gd = node1.get_service_discovery_module()->get_global_discovery();
+    auto &node2_gd = node2.get_service_discovery_module()->get_global_discovery();
+    auto &upstream_gd = upstream.get_service_discovery_module()->get_global_discovery();
 
     node1_gd.add_node(node1_discovery);
     node1_gd.add_node(upstream_discovery);
@@ -191,12 +192,12 @@ struct direct_three_node_apps {
     {
       atapp::protocol::atapp_discovery info;
       node2.pack(info);
-      node2_discovery->copy_from(info, atapp::etcd_discovery_node::node_version());
+      node2_discovery->copy_from(info, atapp::etcd_discovery_node::node_version(), 0);
     }
 
-    auto &node1_gd = node1.get_etcd_module()->get_global_discovery();
-    auto &node2_gd = node2.get_etcd_module()->get_global_discovery();
-    auto &upstream_gd = upstream.get_etcd_module()->get_global_discovery();
+    auto &node1_gd = node1.get_service_discovery_module()->get_global_discovery();
+    auto &node2_gd = node2.get_service_discovery_module()->get_global_discovery();
+    auto &upstream_gd = upstream.get_service_discovery_module()->get_global_discovery();
 
     node1_gd.add_node(node2_discovery);
     node2_gd.add_node(node1_discovery);
diff --git a/test/case/atapp_discovery_reconnect_test.cpp b/test/case/atapp_discovery_reconnect_test.cpp
index 22e61d7..dbd454e 100644
--- a/test/case/atapp_discovery_reconnect_test.cpp
+++ b/test/case/atapp_discovery_reconnect_test.cpp
@@ -13,6 +13,7 @@
 #include <atframe/atapp.h>
 #include <atframe/connectors/atapp_connector_atbus.h>
 #include <atframe/modules/etcd_module.h>
+#include <atframe/modules/service_discovery_module.h>
 #include <detail/libatbus_error.h>
 
 #include <common/file_system.h>
@@ -145,17 +146,17 @@ static void setup_discovery_test_env(atframework::atapp::app &node1, atframework
   {
     atapp::protocol::atapp_discovery info;
     node1.pack(info);
-    n1_disc->copy_from(info, atapp::etcd_discovery_node::node_version());
+    n1_disc->copy_from(info, atapp::etcd_discovery_node::node_version(), 0);
   }
   {
     atapp::protocol::atapp_discovery info;
     node2.pack(info);
-    n2_disc->copy_from(info, atapp::etcd_discovery_node::node_version());
+    n2_disc->copy_from(info, atapp::etcd_discovery_node::node_version(), 0);
   }
   {
     atapp::protocol::atapp_discovery info;
     upstream.pack(info);
-    up_disc->copy_from(info, atapp::etcd_discovery_node::node_version());
+    up_disc->copy_from(info, atapp::etcd_discovery_node::node_version(), 0);
   }
 
   // Add discovery to all apps
@@ -163,7 +164,7 @@ static void setup_discovery_test_env(atframework::atapp::app &node1, atframework
   atfw::util::memory::strong_rc_ptr<atapp::etcd_discovery_node> discs[] = {n1_disc, n2_disc, up_disc};
   for (auto *app : apps) {
     for (auto &disc : discs) {
-      app->get_etcd_module()->get_global_discovery().add_node(disc);
+      app->get_service_discovery_module()->get_global_discovery().add_node(disc);
     }
   }
 
@@ -262,7 +263,7 @@ CASE_TEST(atapp_discovery_reconnect, discovery_delete_then_put_reconnect) {
   }
 
   // Step 2: Remove node2's discovery so update_topology_peer can't find it
-  node1.get_etcd_module()->get_global_discovery().remove_node(n2_disc);
+  node1.get_service_discovery_module()->get_global_discovery().remove_node(n2_disc);
 
   // Step 3: update_topology_peer(upstream=0) unbinds the re-bound proxy (proxy_bus_id→0),
   // then: no bus endpoint, no discovery → set_handle_waiting_discovery → kWaitForDiscoveryToConnect SET
@@ -276,7 +277,7 @@ CASE_TEST(atapp_discovery_reconnect, discovery_delete_then_put_reconnect) {
 
   // ---- Phase 3: Resume via kPut event ----
   // Re-add discovery and fire kPut → resume_handle_discovery clears flag and reconnects
-  node1.get_etcd_module()->get_global_discovery().add_node(n2_disc);
+  node1.get_service_discovery_module()->get_global_discovery().add_node(n2_disc);
   n1_conn->on_discovery_event(atframework::atapp::etcd_discovery_action_t::kPut, n2_disc);
 
   // Verify kWaitForDiscoveryToConnect IS cleared after kPut
@@ -365,7 +366,7 @@ CASE_TEST(atapp_discovery_reconnect, discovery_missing_reconnect_count_accumulat
   CASE_EXPECT_TRUE(n1_conn->is_connection_handle_ready(node2.get_app_id()));
 
   // Remove node2 discovery from node1 so reconnect can't find it
-  node1.get_etcd_module()->get_global_discovery().remove_node(n2_disc);
+  node1.get_service_discovery_module()->get_global_discovery().remove_node(n2_disc);
 
   // Force handle into non-ready state using debug setter — this also starts reconnect timer
   // (set_handle_unready_by_bus_id calls set_handle_unready + setup_reconnect_timer)
@@ -461,7 +462,7 @@ CASE_TEST(atapp_discovery_reconnect, reconnect_exponential_backoff) {
   CASE_EXPECT_TRUE(n1_conn->is_connection_handle_ready(node2.get_app_id()));
 
   // Remove node2 discovery so reconnects will fail
-  node1.get_etcd_module()->get_global_discovery().remove_node(n2_disc);
+  node1.get_service_discovery_module()->get_global_discovery().remove_node(n2_disc);
 
   // Capture now BEFORE set_handle_unready_by_bus_id
   auto now = atframework::atapp::app::get_sys_now();
diff --git a/test/case/atapp_discovery_test.cpp b/test/case/atapp_discovery_test.cpp
index 2af7345..a0662b1 100644
--- a/test/case/atapp_discovery_test.cpp
+++ b/test/case/atapp_discovery_test.cpp
@@ -31,7 +31,7 @@ atapp::etcd_discovery_set::ptr_t create_discovery_set() {
     fake_version.version = 1;
     fake_info.set_id(static_cast<uint64_t>(i));
     fake_info.set_name(atfw::util::string::format("node-{}", i));
-    node->copy_from(fake_info, fake_version);
+    node->copy_from(fake_info, fake_version, 0);
 
     ret->add_node(node);
   }
@@ -142,7 +142,7 @@ CASE_TEST(atapp_discovery, get_discovery_by_metadata) {
   test_node_version.create_revision = 1;
   test_node_version.modify_revision = 2;
   test_node_version.version = 3;
-  node1->copy_from(discovery_data, test_node_version);
+  node1->copy_from(discovery_data, test_node_version, 0);
   CASE_EXPECT_EQ(1, node1->get_version().create_revision);
   CASE_EXPECT_EQ(2, node1->get_version().modify_revision);
   CASE_EXPECT_EQ(3, node1->get_version().version);
@@ -152,14 +152,14 @@ CASE_TEST(atapp_discovery, get_discovery_by_metadata) {
   discovery_data.set_name("node2");
   discovery_data.set_identity("node-dient-2");
   (*discovery_data.mutable_metadata()->mutable_labels())["selector"] = "s2";
-  node2->copy_from(discovery_data, test_node_version);
+  node2->copy_from(discovery_data, test_node_version, 0);
 
   etcd_discovery_node::ptr_t node3 = atfw::util::memory::make_strong_rc<etcd_discovery_node>();
   discovery_data.set_id(3);
   discovery_data.set_name("node3");
   discovery_data.set_identity("node-dient-3");
   (*discovery_data.mutable_metadata()->mutable_labels())["selector"] = "s3";
-  node3->copy_from(discovery_data, test_node_version);
+  node3->copy_from(discovery_data, test_node_version, 0);
 
   discovery_set->add_node(node1);
   discovery_set->add_node(node2);
@@ -424,7 +424,7 @@ CASE_TEST(atapp_discovery, discovery_node_version_update) {
   info_v1.set_id(100);
   info_v1.set_name("node-100");
   info_v1.set_type_name("old-type");
-  node_v1->copy_from(info_v1, ver_v1);
+  node_v1->copy_from(info_v1, ver_v1, 0);
   discovery_set->add_node(node_v1);
 
   auto found = discovery_set->get_node_by_id(100);
@@ -441,7 +441,7 @@ CASE_TEST(atapp_discovery, discovery_node_version_update) {
   info_v2.set_id(100);
   info_v2.set_name("node-100");
   info_v2.set_type_name("new-type");
-  node_v2->copy_from(info_v2, ver_v2);
+  node_v2->copy_from(info_v2, ver_v2, 0);
   discovery_set->add_node(node_v2);
 
   found = discovery_set->get_node_by_id(100);
@@ -460,7 +460,7 @@ CASE_TEST(atapp_discovery, discovery_node_version_stale_skip) {
   ver.version = 3;
   info.set_id(200);
   info.set_name("node-200");
-  node->copy_from(info, ver);
+  node->copy_from(info, ver, 0);
 
   CASE_EXPECT_EQ(20, node->get_version().modify_revision);
   CASE_EXPECT_EQ(3, node->get_version().version);
@@ -470,7 +470,7 @@ CASE_TEST(atapp_discovery, discovery_node_version_stale_skip) {
   stale_ver.create_revision = 5;
   stale_ver.modify_revision = 15;  // lower than current 20
   stale_ver.version = 1;           // lower than current 3
-  node->update_version(stale_ver, true);
+  node->update_version(stale_ver, true, 0);
 
   // Version fields should NOT have decreased
   CASE_EXPECT_EQ(10, node->get_version().create_revision);
@@ -482,7 +482,7 @@ CASE_TEST(atapp_discovery, discovery_node_version_stale_skip) {
   newer_ver.create_revision = 10;
   newer_ver.modify_revision = 30;
   newer_ver.version = 5;
-  node->update_version(newer_ver, true);
+  node->update_version(newer_ver, true, 0);
 
   CASE_EXPECT_EQ(30, node->get_version().modify_revision);
   CASE_EXPECT_EQ(5, node->get_version().version);
@@ -506,7 +506,7 @@ CASE_TEST(atapp_discovery, discovery_add_remove_stress) {
     fake_version.version = 1;
     fake_info.set_id(static_cast<uint64_t>(i + 1));
     fake_info.set_name(atfw::util::string::format("stress-node-{}", i));
-    node->copy_from(fake_info, fake_version);
+    node->copy_from(fake_info, fake_version, 0);
     discovery_set->add_node(node);
     nodes.push_back(node);
   }
@@ -572,7 +572,7 @@ CASE_TEST(atapp_discovery, discovery_node_ingress_round_robin) {
   auto *gw3 = fake_info.add_gateways();
   gw3->set_address("ipv4://10.0.0.3:8003");
 
-  node->copy_from(fake_info, fake_version);
+  node->copy_from(fake_info, fake_version, 0);
 
   CASE_EXPECT_EQ(3, node->get_ingress_size());
 
@@ -597,7 +597,7 @@ CASE_TEST(atapp_discovery, discovery_node_ingress_round_robin) {
   info_no_gw.set_id(301);
   info_no_gw.set_name("listen-node");
   info_no_gw.add_listen("ipv6://[::1]:9000");
-  node2->copy_from(info_no_gw, fake_version);
+  node2->copy_from(info_no_gw, fake_version, 0);
 
   CASE_EXPECT_EQ(1, node2->get_ingress_size());
   const auto &ingress = node2->next_ingress_gateway();
diff --git a/test/case/atapp_downstream_send_test.cpp b/test/case/atapp_downstream_send_test.cpp
index 93314a7..13fbd61 100644
--- a/test/case/atapp_downstream_send_test.cpp
+++ b/test/case/atapp_downstream_send_test.cpp
@@ -7,6 +7,7 @@
 #include <atframe/atapp.h>
 #include <atframe/connectors/atapp_connector_atbus.h>
 #include <atframe/modules/etcd_module.h>
+#include <atframe/modules/service_discovery_module.h>
 #include <detail/libatbus_error.h>
 
 #include <common/file_system.h>
@@ -113,16 +114,16 @@ struct downstream_two_node_apps {
     {
       atapp::protocol::atapp_discovery info;
       upstream.pack(info);
-      upstream_discovery->copy_from(info, atapp::etcd_discovery_node::node_version());
+      upstream_discovery->copy_from(info, atapp::etcd_discovery_node::node_version(), 0);
     }
     {
       atapp::protocol::atapp_discovery info;
       downstream.pack(info);
-      downstream_discovery->copy_from(info, atapp::etcd_discovery_node::node_version());
+      downstream_discovery->copy_from(info, atapp::etcd_discovery_node::node_version(), 0);
     }
 
-    auto &up_gd = upstream.get_etcd_module()->get_global_discovery();
-    auto &down_gd = downstream.get_etcd_module()->get_global_discovery();
+    auto &up_gd = upstream.get_service_discovery_module()->get_global_discovery();
+    auto &down_gd = downstream.get_service_discovery_module()->get_global_discovery();
 
     up_gd.add_node(upstream_discovery);
     up_gd.add_node(downstream_discovery);
@@ -137,11 +138,11 @@ struct downstream_two_node_apps {
     {
       atapp::protocol::atapp_discovery info;
       upstream.pack(info);
-      upstream_discovery->copy_from(info, atapp::etcd_discovery_node::node_version());
+      upstream_discovery->copy_from(info, atapp::etcd_discovery_node::node_version(), 0);
     }
 
-    auto &up_gd = upstream.get_etcd_module()->get_global_discovery();
-    auto &down_gd = downstream.get_etcd_module()->get_global_discovery();
+    auto &up_gd = upstream.get_service_discovery_module()->get_global_discovery();
+    auto &down_gd = downstream.get_service_discovery_module()->get_global_discovery();
 
     up_gd.add_node(upstream_discovery);
     down_gd.add_node(upstream_discovery);
@@ -152,11 +153,11 @@ struct downstream_two_node_apps {
     {
       atapp::protocol::atapp_discovery info;
       downstream.pack(info);
-      downstream_discovery->copy_from(info, atapp::etcd_discovery_node::node_version());
+      downstream_discovery->copy_from(info, atapp::etcd_discovery_node::node_version(), 0);
     }
 
-    auto &up_gd = upstream.get_etcd_module()->get_global_discovery();
-    auto &down_gd = downstream.get_etcd_module()->get_global_discovery();
+    auto &up_gd = upstream.get_service_discovery_module()->get_global_discovery();
+    auto &down_gd = downstream.get_service_discovery_module()->get_global_discovery();
 
     up_gd.add_node(downstream_discovery);
     down_gd.add_node(downstream_discovery);
@@ -226,17 +227,17 @@ CASE_TEST(atapp_downstream_send, downstream_not_connected_pending) {
   {
     atapp::protocol::atapp_discovery info;
     apps.upstream.pack(info);
-    apps.upstream_discovery->copy_from(info, atapp::etcd_discovery_node::node_version());
+    apps.upstream_discovery->copy_from(info, atapp::etcd_discovery_node::node_version(), 0);
   }
   {
     atapp::protocol::atapp_discovery info;
     apps.downstream.pack(info);
-    apps.downstream_discovery->copy_from(info, atapp::etcd_discovery_node::node_version());
+    apps.downstream_discovery->copy_from(info, atapp::etcd_discovery_node::node_version(), 0);
   }
 
   // Inject upstream discovery on both sides
-  auto &up_gd = apps.upstream.get_etcd_module()->get_global_discovery();
-  auto &down_gd = apps.downstream.get_etcd_module()->get_global_discovery();
+  auto &up_gd = apps.upstream.get_service_discovery_module()->get_global_discovery();
+  auto &down_gd = apps.downstream.get_service_discovery_module()->get_global_discovery();
   up_gd.add_node(apps.upstream_discovery);
   down_gd.add_node(apps.upstream_discovery);
 
diff --git a/test/case/atapp_error_recovery_test.cpp b/test/case/atapp_error_recovery_test.cpp
index 15c122a..a848946 100644
--- a/test/case/atapp_error_recovery_test.cpp
+++ b/test/case/atapp_error_recovery_test.cpp
@@ -13,6 +13,7 @@
 #include <atframe/atapp.h>
 #include <atframe/connectors/atapp_connector_atbus.h>
 #include <atframe/modules/etcd_module.h>
+#include <atframe/modules/service_discovery_module.h>
 #include <detail/libatbus_error.h>
 
 #include <common/file_system.h>
@@ -146,17 +147,17 @@ static void setup_recovery_test_env(atframework::atapp::app &node1, atframework:
   {
     atapp::protocol::atapp_discovery info;
     node1.pack(info);
-    n1_disc->copy_from(info, atapp::etcd_discovery_node::node_version());
+    n1_disc->copy_from(info, atapp::etcd_discovery_node::node_version(), 0);
   }
   {
     atapp::protocol::atapp_discovery info;
     proxy_node.pack(info);
-    proxy_disc->copy_from(info, atapp::etcd_discovery_node::node_version());
+    proxy_disc->copy_from(info, atapp::etcd_discovery_node::node_version(), 0);
   }
   {
     atapp::protocol::atapp_discovery info;
     downstream.pack(info);
-    down_disc->copy_from(info, atapp::etcd_discovery_node::node_version());
+    down_disc->copy_from(info, atapp::etcd_discovery_node::node_version(), 0);
   }
 
   // Add discovery to all apps
@@ -164,7 +165,7 @@ static void setup_recovery_test_env(atframework::atapp::app &node1, atframework:
   atfw::util::memory::strong_rc_ptr<atapp::etcd_discovery_node> discs[] = {n1_disc, proxy_disc, down_disc};
   for (auto *app : apps) {
     for (auto &disc : discs) {
-      app->get_etcd_module()->get_global_discovery().add_node(disc);
+      app->get_service_discovery_module()->get_global_discovery().add_node(disc);
     }
   }
 
@@ -234,17 +235,17 @@ CASE_TEST(atapp_error_recovery, send_fail_reconnect_then_success) {
   {
     atapp::protocol::atapp_discovery info;
     node1.pack(info);
-    n1_disc->copy_from(info, atapp::etcd_discovery_node::node_version());
+    n1_disc->copy_from(info, atapp::etcd_discovery_node::node_version(), 0);
   }
   {
     atapp::protocol::atapp_discovery info;
     node2.pack(info);
-    n2_disc->copy_from(info, atapp::etcd_discovery_node::node_version());
+    n2_disc->copy_from(info, atapp::etcd_discovery_node::node_version(), 0);
   }
   {
     atapp::protocol::atapp_discovery info;
     upstream.pack(info);
-    up_disc->copy_from(info, atapp::etcd_discovery_node::node_version());
+    up_disc->copy_from(info, atapp::etcd_discovery_node::node_version(), 0);
   }
 
   // Add discovery to all apps
@@ -252,7 +253,7 @@ CASE_TEST(atapp_error_recovery, send_fail_reconnect_then_success) {
   atfw::util::memory::strong_rc_ptr<atapp::etcd_discovery_node> discs[] = {n1_disc, n2_disc, up_disc};
   for (auto *app : apps) {
     for (auto &disc : discs) {
-      app->get_etcd_module()->get_global_discovery().add_node(disc);
+      app->get_service_discovery_module()->get_global_discovery().add_node(disc);
     }
   }
 
diff --git a/test/case/atapp_etcd_cluster_test.cpp b/test/case/atapp_etcd_cluster_test.cpp
index 423403a..0cd674a 100644
--- a/test/case/atapp_etcd_cluster_test.cpp
+++ b/test/case/atapp_etcd_cluster_test.cpp
@@ -3,6 +3,7 @@
 
 #include <atframe/atapp.h>
 #include <atframe/modules/etcd_module.h>
+#include <atframe/modules/service_discovery_module.h>
 
 #include <atframe/etcdcli/etcd_cluster.h>
 #include <atframe/etcdcli/etcd_keepalive.h>
@@ -222,13 +223,7 @@ CASE_TEST(atapp_etcd_cluster, cluster_init_and_connect) {  // NOLINT
   const char *args[] = {"app1", "-c", setup.conf_path.c_str(), "start"};
   CASE_EXPECT_EQ(0, app1.init(nullptr, 4, args, nullptr));
 
-  auto etcd_mod = app1.get_etcd_module();
-  CASE_EXPECT_TRUE(!!etcd_mod);
-  if (!etcd_mod) {
-    return;
-  }
-
-  auto &cluster = etcd_mod->get_raw_etcd_ctx();
+  auto &cluster = app1.get_service_discovery_module()->get_raw_etcd_ctx();
 
   // Cluster should be available after init
   CASE_EXPECT_TRUE(cluster.is_available());
@@ -257,13 +252,7 @@ CASE_TEST(atapp_etcd_cluster, cluster_member_list_discovery) {
   const char *args[] = {"app1", "-c", setup.conf_path.c_str(), "start"};
   CASE_EXPECT_EQ(0, app1.init(nullptr, 4, args, nullptr));
 
-  auto etcd_mod = app1.get_etcd_module();
-  CASE_EXPECT_TRUE(!!etcd_mod);
-  if (!etcd_mod) {
-    return;
-  }
-
-  auto &cluster = etcd_mod->get_raw_etcd_ctx();
+  auto &cluster = app1.get_service_discovery_module()->get_raw_etcd_ctx();
 
   std::vector<atframework::atapp::app *> apps = {&app1};
   run_apps_noblock(apps, 16);
@@ -295,13 +284,7 @@ CASE_TEST(atapp_etcd_cluster, cluster_lease_grant_and_keepalive) {
   const char *args[] = {"app1", "-c", setup.conf_path.c_str(), "start"};
   CASE_EXPECT_EQ(0, app1.init(nullptr, 4, args, nullptr));
 
-  auto etcd_mod = app1.get_etcd_module();
-  CASE_EXPECT_TRUE(!!etcd_mod);
-  if (!etcd_mod) {
-    return;
-  }
-
-  auto &cluster = etcd_mod->get_raw_etcd_ctx();
+  auto &cluster = app1.get_service_discovery_module()->get_raw_etcd_ctx();
 
   std::vector<atframework::atapp::app *> apps = {&app1};
   run_apps_noblock(apps, 16);
@@ -332,13 +315,7 @@ CASE_TEST(atapp_etcd_cluster, cluster_close_revoke_lease) {
   const char *args[] = {"app1", "-c", setup.conf_path.c_str(), "start"};
   CASE_EXPECT_EQ(0, app1.init(nullptr, 4, args, nullptr));
 
-  auto etcd_mod = app1.get_etcd_module();
-  CASE_EXPECT_TRUE(!!etcd_mod);
-  if (!etcd_mod) {
-    return;
-  }
-
-  auto &cluster = etcd_mod->get_raw_etcd_ctx();
+  auto &cluster = app1.get_service_discovery_module()->get_raw_etcd_ctx();
 
   std::vector<atframework::atapp::app *> apps = {&app1};
   run_apps_noblock(apps, 16);
@@ -390,13 +367,7 @@ CASE_TEST(atapp_etcd_cluster, cluster_stats_tracking) {
   const char *args[] = {"app1", "-c", setup.conf_path.c_str(), "start"};
   CASE_EXPECT_EQ(0, app1.init(nullptr, 4, args, nullptr));
 
-  auto etcd_mod = app1.get_etcd_module();
-  CASE_EXPECT_TRUE(!!etcd_mod);
-  if (!etcd_mod) {
-    return;
-  }
-
-  auto &cluster = etcd_mod->get_raw_etcd_ctx();
+  auto &cluster = app1.get_service_discovery_module()->get_raw_etcd_ctx();
 
   std::vector<atframework::atapp::app *> apps = {&app1};
   run_apps_noblock(apps, 32);
@@ -424,13 +395,7 @@ CASE_TEST(atapp_etcd_cluster, cluster_event_up_down_callbacks) {
   const char *args[] = {"app1", "-c", setup.conf_path.c_str(), "start"};
   CASE_EXPECT_EQ(0, app1.init(nullptr, 4, args, nullptr));
 
-  auto etcd_mod = app1.get_etcd_module();
-  CASE_EXPECT_TRUE(!!etcd_mod);
-  if (!etcd_mod) {
-    return;
-  }
-
-  auto &cluster = etcd_mod->get_raw_etcd_ctx();
+  auto &cluster = app1.get_service_discovery_module()->get_raw_etcd_ctx();
 
   int up_count = 0;
   int down_count = 0;
@@ -472,13 +437,7 @@ CASE_TEST(atapp_etcd_cluster, keepalive_set_value_and_read) {
   const char *args[] = {"app1", "-c", setup.conf_path.c_str(), "start"};
   CASE_EXPECT_EQ(0, app1.init(nullptr, 4, args, nullptr));
 
-  auto etcd_mod = app1.get_etcd_module();
-  CASE_EXPECT_TRUE(!!etcd_mod);
-  if (!etcd_mod) {
-    return;
-  }
-
-  auto &cluster = etcd_mod->get_raw_etcd_ctx();
+  auto &cluster = app1.get_service_discovery_module()->get_raw_etcd_ctx();
 
   std::vector<atframework::atapp::app *> apps = {&app1};
   run_apps_noblock(apps, 16);
@@ -524,13 +483,7 @@ CASE_TEST(atapp_etcd_cluster, keepalive_update_value) {
   const char *args[] = {"app1", "-c", setup.conf_path.c_str(), "start"};
   CASE_EXPECT_EQ(0, app1.init(nullptr, 4, args, nullptr));
 
-  auto etcd_mod = app1.get_etcd_module();
-  CASE_EXPECT_TRUE(!!etcd_mod);
-  if (!etcd_mod) {
-    return;
-  }
-
-  auto &cluster = etcd_mod->get_raw_etcd_ctx();
+  auto &cluster = app1.get_service_discovery_module()->get_raw_etcd_ctx();
 
   std::vector<atframework::atapp::app *> apps = {&app1};
   run_apps_noblock(apps, 16);
@@ -583,13 +536,7 @@ CASE_TEST(atapp_etcd_cluster, keepalive_lease_binding) {
   const char *args[] = {"app1", "-c", setup.conf_path.c_str(), "start"};
   CASE_EXPECT_EQ(0, app1.init(nullptr, 4, args, nullptr));
 
-  auto etcd_mod = app1.get_etcd_module();
-  CASE_EXPECT_TRUE(!!etcd_mod);
-  if (!etcd_mod) {
-    return;
-  }
-
-  auto &cluster = etcd_mod->get_raw_etcd_ctx();
+  auto &cluster = app1.get_service_discovery_module()->get_raw_etcd_ctx();
 
   std::vector<atframework::atapp::app *> apps = {&app1};
   run_apps_noblock(apps, 16);
@@ -640,13 +587,7 @@ CASE_TEST(atapp_etcd_cluster, keepalive_checker_conflict) {
   const char *args[] = {"app1", "-c", setup.conf_path.c_str(), "start"};
   CASE_EXPECT_EQ(0, app1.init(nullptr, 4, args, nullptr));
 
-  auto etcd_mod = app1.get_etcd_module();
-  CASE_EXPECT_TRUE(!!etcd_mod);
-  if (!etcd_mod) {
-    return;
-  }
-
-  auto &cluster = etcd_mod->get_raw_etcd_ctx();
+  auto &cluster = app1.get_service_discovery_module()->get_raw_etcd_ctx();
 
   std::vector<atframework::atapp::app *> apps = {&app1};
   run_apps_noblock(apps, 16);
@@ -700,13 +641,7 @@ CASE_TEST(atapp_etcd_cluster, keepalive_checker_same_identity) {
   const char *args[] = {"app1", "-c", setup.conf_path.c_str(), "start"};
   CASE_EXPECT_EQ(0, app1.init(nullptr, 4, args, nullptr));
 
-  auto etcd_mod = app1.get_etcd_module();
-  CASE_EXPECT_TRUE(!!etcd_mod);
-  if (!etcd_mod) {
-    return;
-  }
-
-  auto &cluster = etcd_mod->get_raw_etcd_ctx();
+  auto &cluster = app1.get_service_discovery_module()->get_raw_etcd_ctx();
 
   std::vector<atframework::atapp::app *> apps = {&app1};
   run_apps_noblock(apps, 16);
@@ -757,13 +692,7 @@ CASE_TEST(atapp_etcd_cluster, keepalive_remove_and_readd) {
   const char *args[] = {"app1", "-c", setup.conf_path.c_str(), "start"};
   CASE_EXPECT_EQ(0, app1.init(nullptr, 4, args, nullptr));
 
-  auto etcd_mod = app1.get_etcd_module();
-  CASE_EXPECT_TRUE(!!etcd_mod);
-  if (!etcd_mod) {
-    return;
-  }
-
-  auto &cluster = etcd_mod->get_raw_etcd_ctx();
+  auto &cluster = app1.get_service_discovery_module()->get_raw_etcd_ctx();
 
   std::vector<atframework::atapp::app *> apps = {&app1};
   run_apps_noblock(apps, 16);
@@ -824,13 +753,7 @@ CASE_TEST(atapp_etcd_cluster, watcher_initial_snapshot) {
   const char *args[] = {"app1", "-c", setup.conf_path.c_str(), "start"};
   CASE_EXPECT_EQ(0, app1.init(nullptr, 4, args, nullptr));
 
-  auto etcd_mod = app1.get_etcd_module();
-  CASE_EXPECT_TRUE(!!etcd_mod);
-  if (!etcd_mod) {
-    return;
-  }
-
-  auto &cluster = etcd_mod->get_raw_etcd_ctx();
+  auto &cluster = app1.get_service_discovery_module()->get_raw_etcd_ctx();
 
   std::vector<atframework::atapp::app *> apps = {&app1};
   run_apps_noblock(apps, 16);
@@ -893,13 +816,7 @@ CASE_TEST(atapp_etcd_cluster, watcher_put_event) {
   const char *args[] = {"app1", "-c", setup.conf_path.c_str(), "start"};
   CASE_EXPECT_EQ(0, app1.init(nullptr, 4, args, nullptr));
 
-  auto etcd_mod = app1.get_etcd_module();
-  CASE_EXPECT_TRUE(!!etcd_mod);
-  if (!etcd_mod) {
-    return;
-  }
-
-  auto &cluster = etcd_mod->get_raw_etcd_ctx();
+  auto &cluster = app1.get_service_discovery_module()->get_raw_etcd_ctx();
 
   std::vector<atframework::atapp::app *> apps = {&app1};
   run_apps_noblock(apps, 16);
@@ -970,13 +887,7 @@ CASE_TEST(atapp_etcd_cluster, watcher_delete_event) {
   const char *args[] = {"app1", "-c", setup.conf_path.c_str(), "start"};
   CASE_EXPECT_EQ(0, app1.init(nullptr, 4, args, nullptr));
 
-  auto etcd_mod = app1.get_etcd_module();
-  CASE_EXPECT_TRUE(!!etcd_mod);
-  if (!etcd_mod) {
-    return;
-  }
-
-  auto &cluster = etcd_mod->get_raw_etcd_ctx();
+  auto &cluster = app1.get_service_discovery_module()->get_raw_etcd_ctx();
 
   std::vector<atframework::atapp::app *> apps = {&app1};
   run_apps_noblock(apps, 16);
@@ -1048,13 +959,7 @@ CASE_TEST(atapp_etcd_cluster, watcher_prefix_range) {
   const char *args[] = {"app1", "-c", setup.conf_path.c_str(), "start"};
   CASE_EXPECT_EQ(0, app1.init(nullptr, 4, args, nullptr));
 
-  auto etcd_mod = app1.get_etcd_module();
-  CASE_EXPECT_TRUE(!!etcd_mod);
-  if (!etcd_mod) {
-    return;
-  }
-
-  auto &cluster = etcd_mod->get_raw_etcd_ctx();
+  auto &cluster = app1.get_service_discovery_module()->get_raw_etcd_ctx();
 
   std::vector<atframework::atapp::app *> apps = {&app1};
   run_apps_noblock(apps, 16);
@@ -1134,13 +1039,7 @@ CASE_TEST(atapp_etcd_cluster, watcher_reconnect_after_timeout) {
   const char *args[] = {"app1", "-c", setup.conf_path.c_str(), "start"};
   CASE_EXPECT_EQ(0, app1.init(nullptr, 4, args, nullptr));
 
-  auto etcd_mod = app1.get_etcd_module();
-  CASE_EXPECT_TRUE(!!etcd_mod);
-  if (!etcd_mod) {
-    return;
-  }
-
-  auto &cluster = etcd_mod->get_raw_etcd_ctx();
+  auto &cluster = app1.get_service_discovery_module()->get_raw_etcd_ctx();
 
   std::vector<atframework::atapp::app *> apps = {&app1};
   run_apps_noblock(apps, 16);
@@ -1225,13 +1124,7 @@ CASE_TEST(atapp_etcd_cluster, watcher_revision_continuity) {
   const char *args[] = {"app1", "-c", setup.conf_path.c_str(), "start"};
   CASE_EXPECT_EQ(0, app1.init(nullptr, 4, args, nullptr));
 
-  auto etcd_mod = app1.get_etcd_module();
-  CASE_EXPECT_TRUE(!!etcd_mod);
-  if (!etcd_mod) {
-    return;
-  }
-
-  auto &cluster = etcd_mod->get_raw_etcd_ctx();
+  auto &cluster = app1.get_service_discovery_module()->get_raw_etcd_ctx();
 
   std::vector<atframework::atapp::app *> apps = {&app1};
   run_apps_noblock(apps, 16);
diff --git a/test/case/atapp_etcd_module_test.cpp b/test/case/atapp_etcd_module_test.cpp
index 8d4f6f6..24c693d 100644
--- a/test/case/atapp_etcd_module_test.cpp
+++ b/test/case/atapp_etcd_module_test.cpp
@@ -3,6 +3,7 @@
 
 #include <atframe/atapp.h>
 #include <atframe/modules/etcd_module.h>
+#include <atframe/modules/service_discovery_module.h>
 
 #include <atframe/etcdcli/etcd_cluster.h>
 #include <atframe/etcdcli/etcd_discovery.h>
@@ -103,23 +104,22 @@ CASE_TEST(atapp_etcd_module, init_and_ready) {
   CASE_EXPECT_EQ(0, app1.init(nullptr, 4, args, nullptr));
 
   // After init, etcd module should be enabled and the cluster should be available
-  auto etcd_mod = app1.get_etcd_module();
-  CASE_EXPECT_TRUE(!!etcd_mod);
-  if (!etcd_mod) {
+  auto discovery_module = app1.get_service_discovery_module();
+  CASE_EXPECT_TRUE(!!discovery_module);
+  if (!discovery_module) {
     return;
   }
 
-  CASE_EXPECT_TRUE(etcd_mod->is_etcd_enabled());
-  CASE_EXPECT_TRUE(etcd_mod->get_raw_etcd_ctx().is_available());
+  CASE_EXPECT_TRUE(discovery_module->get_raw_etcd_ctx().is_available());
 
   // Tick a few times to ensure stable state
   std::vector<atframework::atapp::app *> apps = {&app1};
   run_apps_noblock(apps, 32);
 
-  CASE_EXPECT_TRUE(etcd_mod->get_raw_etcd_ctx().is_available());
-  CASE_EXPECT_NE(0, static_cast<int64_t>(etcd_mod->get_raw_etcd_ctx().get_lease()));
+  CASE_EXPECT_TRUE(discovery_module->get_raw_etcd_ctx().is_available());
+  CASE_EXPECT_NE(0, static_cast<int64_t>(discovery_module->get_raw_etcd_ctx().get_lease()));
 
-  CASE_MSG_INFO() << "etcd lease: " << etcd_mod->get_raw_etcd_ctx().get_lease() << '\n';
+  CASE_MSG_INFO() << "etcd lease: " << discovery_module->get_raw_etcd_ctx().get_lease() << '\n';
 }
 
 // ============================================================
@@ -144,14 +144,14 @@ CASE_TEST(atapp_etcd_module, keepalive_paths) {
   const char *args[] = {"app1", "-c", conf_path.c_str(), "start"};
   CASE_EXPECT_EQ(0, app1.init(nullptr, 4, args, nullptr));
 
-  auto etcd_mod = app1.get_etcd_module();
-  CASE_EXPECT_TRUE(!!etcd_mod);
-  if (!etcd_mod) {
+  auto discovery_module = app1.get_service_discovery_module();
+  CASE_EXPECT_TRUE(!!discovery_module);
+  if (!discovery_module) {
     return;
   }
 
   // Check by_id path
-  std::string by_id_path = etcd_mod->get_discovery_by_id_path();
+  std::string by_id_path = discovery_module->get_discovery_by_id_path(app1, discovery_module->get_configure_path());
   CASE_EXPECT_FALSE(by_id_path.empty());
   CASE_MSG_INFO() << "by_id_path: " << by_id_path << '\n';
   // Should contain "by_id" and the app name
@@ -159,14 +159,14 @@ CASE_TEST(atapp_etcd_module, keepalive_paths) {
   CASE_EXPECT_NE(std::string::npos, by_id_path.find(app1.get_app_name()));
 
   // Check by_name path
-  std::string by_name_path = etcd_mod->get_discovery_by_name_path();
+  std::string by_name_path = discovery_module->get_discovery_by_name_path(app1, discovery_module->get_configure_path());
   CASE_EXPECT_FALSE(by_name_path.empty());
   CASE_MSG_INFO() << "by_name_path: " << by_name_path << '\n';
   CASE_EXPECT_NE(std::string::npos, by_name_path.find("by_name"));
   CASE_EXPECT_NE(std::string::npos, by_name_path.find(app1.get_app_name()));
 
   // Check topology path
-  std::string topology_path = etcd_mod->get_topology_path();
+  std::string topology_path = discovery_module->get_topology_path(app1, discovery_module->get_configure_path());
   CASE_EXPECT_FALSE(topology_path.empty());
   CASE_MSG_INFO() << "topology_path: " << topology_path << '\n';
   CASE_EXPECT_NE(std::string::npos, topology_path.find("topology"));
@@ -195,16 +195,16 @@ CASE_TEST(atapp_etcd_module, watcher_paths) {
   const char *args[] = {"app1", "-c", conf_path.c_str(), "start"};
   CASE_EXPECT_EQ(0, app1.init(nullptr, 4, args, nullptr));
 
-  auto etcd_mod = app1.get_etcd_module();
-  CASE_EXPECT_TRUE(!!etcd_mod);
-  if (!etcd_mod) {
+  auto discovery_module = app1.get_service_discovery_module();
+  CASE_EXPECT_TRUE(!!discovery_module);
+  if (!discovery_module) {
     return;
   }
 
   // Watcher paths should be prefix paths (without node-specific suffix)
-  std::string by_id_watcher = etcd_mod->get_discovery_by_id_watcher_path();
-  std::string by_name_watcher = etcd_mod->get_discovery_by_name_watcher_path();
-  std::string topology_watcher = etcd_mod->get_topology_watcher_path();
+  std::string by_id_watcher = discovery_module->get_discovery_by_id_watcher_path(app1, discovery_module->get_configure_path());
+  std::string by_name_watcher = discovery_module->get_discovery_by_name_watcher_path(app1, discovery_module->get_configure_path());
+  std::string topology_watcher = discovery_module->get_topology_watcher_path(app1, discovery_module->get_configure_path());
 
   CASE_EXPECT_FALSE(by_id_watcher.empty());
   CASE_EXPECT_FALSE(by_name_watcher.empty());
@@ -220,9 +220,9 @@ CASE_TEST(atapp_etcd_module, watcher_paths) {
 
   // Watcher paths should NOT contain the app name (they watch the whole prefix)
   // The keepalive paths should be longer (have the app-specific suffix)
-  CASE_EXPECT_LT(by_id_watcher.size(), etcd_mod->get_discovery_by_id_path().size());
-  CASE_EXPECT_LT(by_name_watcher.size(), etcd_mod->get_discovery_by_name_path().size());
-  CASE_EXPECT_LT(topology_watcher.size(), etcd_mod->get_topology_path().size());
+  CASE_EXPECT_LT(by_id_watcher.size(), discovery_module->get_discovery_by_id_path(app1, discovery_module->get_configure_path()).size());
+  CASE_EXPECT_LT(by_name_watcher.size(), discovery_module->get_discovery_by_name_path(app1, discovery_module->get_configure_path()).size());
+  CASE_EXPECT_LT(topology_watcher.size(), discovery_module->get_topology_path(app1, discovery_module->get_configure_path()).size());
 }
 
 // ============================================================
@@ -247,23 +247,23 @@ CASE_TEST(atapp_etcd_module, topology_registration) {
   const char *args[] = {"app1", "-c", conf_path.c_str(), "start"};
   CASE_EXPECT_EQ(0, app1.init(nullptr, 4, args, nullptr));
 
-  auto etcd_mod = app1.get_etcd_module();
-  CASE_EXPECT_TRUE(!!etcd_mod);
-  if (!etcd_mod) {
+  auto discovery_module = app1.get_service_discovery_module();
+  CASE_EXPECT_TRUE(!!discovery_module);
+  if (!discovery_module) {
     return;
   }
 
   // Tick to let watcher events come in
   std::vector<atframework::atapp::app *> apps = {&app1};
 
-  bool has_topology = run_apps_until(apps, [&etcd_mod, &app1]() {
-    const auto &topo_set = etcd_mod->get_topology_info_set();
+  bool has_topology = run_apps_until(apps, [&discovery_module, &app1]() {
+    const auto &topo_set = discovery_module->get_topology_info_set();
     return topo_set.find(app1.get_id()) != topo_set.end();
   });
 
   CASE_EXPECT_TRUE(has_topology);
   if (has_topology) {
-    const auto &topo_set = etcd_mod->get_topology_info_set();
+    const auto &topo_set = discovery_module->get_topology_info_set();
     auto it = topo_set.find(app1.get_id());
     CASE_EXPECT_TRUE(it != topo_set.end());
     if (it != topo_set.end()) {
@@ -299,17 +299,17 @@ CASE_TEST(atapp_etcd_module, discovery_snapshot) {
   const char *args[] = {"app1", "-c", conf_path.c_str(), "start"};
   CASE_EXPECT_EQ(0, app1.init(nullptr, 4, args, nullptr));
 
-  auto etcd_mod = app1.get_etcd_module();
-  CASE_EXPECT_TRUE(!!etcd_mod);
-  if (!etcd_mod) {
+  auto discovery_module = app1.get_service_discovery_module();
+  CASE_EXPECT_TRUE(!!discovery_module);
+  if (!discovery_module) {
     return;
   }
 
   std::vector<atframework::atapp::app *> apps = {&app1};
-  bool has_snapshot = run_apps_until(apps, [&etcd_mod]() { return etcd_mod->has_discovery_snapshot(); });
+  bool has_snapshot = run_apps_until(apps, [&discovery_module]() { return discovery_module->has_discovery_snapshot(); });
 
   CASE_EXPECT_TRUE(has_snapshot);
-  CASE_MSG_INFO() << "has_discovery_snapshot: " << (etcd_mod->has_discovery_snapshot() ? "true" : "false") << '\n';
+  CASE_MSG_INFO() << "has_discovery_snapshot: " << (discovery_module->has_discovery_snapshot() ? "true" : "false") << '\n';
 }
 
 // ============================================================
@@ -334,17 +334,17 @@ CASE_TEST(atapp_etcd_module, topology_snapshot) {
   const char *args[] = {"app1", "-c", conf_path.c_str(), "start"};
   CASE_EXPECT_EQ(0, app1.init(nullptr, 4, args, nullptr));
 
-  auto etcd_mod = app1.get_etcd_module();
-  CASE_EXPECT_TRUE(!!etcd_mod);
-  if (!etcd_mod) {
+  auto discovery_module = app1.get_service_discovery_module();
+  CASE_EXPECT_TRUE(!!discovery_module);
+  if (!discovery_module) {
     return;
   }
 
   std::vector<atframework::atapp::app *> apps = {&app1};
-  bool has_snapshot = run_apps_until(apps, [&etcd_mod]() { return etcd_mod->has_topology_snapshot(); });
+  bool has_snapshot = run_apps_until(apps, [&discovery_module]() { return discovery_module->has_topology_snapshot(); });
 
   CASE_EXPECT_TRUE(has_snapshot);
-  CASE_MSG_INFO() << "has_topology_snapshot: " << (etcd_mod->has_topology_snapshot() ? "true" : "false") << '\n';
+  CASE_MSG_INFO() << "has_topology_snapshot: " << (discovery_module->has_topology_snapshot() ? "true" : "false") << '\n';
 }
 
 // ============================================================
@@ -374,25 +374,25 @@ CASE_TEST(atapp_etcd_module, discovery_registration) {
   CASE_EXPECT_EQ(0, app1.init(nullptr, 4, args1, nullptr));
   CASE_EXPECT_EQ(0, app2.init(nullptr, 4, args2, nullptr));
 
-  auto etcd_mod1 = app1.get_etcd_module();
-  auto etcd_mod2 = app2.get_etcd_module();
-  CASE_EXPECT_TRUE(!!etcd_mod1);
-  CASE_EXPECT_TRUE(!!etcd_mod2);
-  if (!etcd_mod1 || !etcd_mod2) {
+  auto discovery_module1 = app1.get_service_discovery_module();
+  auto discovery_module2 = app2.get_service_discovery_module();
+  CASE_EXPECT_TRUE(!!discovery_module1);
+  CASE_EXPECT_TRUE(!!discovery_module2);
+  if (!discovery_module1 || !discovery_module2) {
     return;
   }
 
   std::vector<atframework::atapp::app *> apps = {&app1, &app2};
 
   // Wait for node1 to discover node2 through etcd watcher events
-  bool node1_found_node2 = run_apps_until(apps, [&etcd_mod1, &app2]() {
-    auto node = etcd_mod1->get_global_discovery().get_node_by_id(app2.get_id());
+  bool node1_found_node2 = run_apps_until(apps, [&discovery_module1, &app2]() {
+    auto node = discovery_module1->get_global_discovery().get_node_by_id(app2.get_id());
     return !!node;
   });
 
   CASE_EXPECT_TRUE(node1_found_node2);
   if (node1_found_node2) {
-    auto node = etcd_mod1->get_global_discovery().get_node_by_id(app2.get_id());
+    auto node = discovery_module1->get_global_discovery().get_node_by_id(app2.get_id());
     CASE_EXPECT_TRUE(!!node);
     if (node) {
       CASE_EXPECT_EQ(app2.get_id(), node->get_discovery_info().id());
@@ -403,14 +403,14 @@ CASE_TEST(atapp_etcd_module, discovery_registration) {
   }
 
   // Also check node2 discovers node1
-  bool node2_found_node1 = run_apps_until(apps, [&etcd_mod2, &app1]() {
-    auto node = etcd_mod2->get_global_discovery().get_node_by_id(app1.get_id());
+  bool node2_found_node1 = run_apps_until(apps, [&discovery_module2, &app1]() {
+    auto node = discovery_module2->get_global_discovery().get_node_by_id(app1.get_id());
     return !!node;
   });
 
   CASE_EXPECT_TRUE(node2_found_node1);
   if (node2_found_node1) {
-    auto node = etcd_mod2->get_global_discovery().get_node_by_id(app1.get_id());
+    auto node = discovery_module2->get_global_discovery().get_node_by_id(app1.get_id());
     CASE_EXPECT_TRUE(!!node);
     if (node) {
       CASE_EXPECT_EQ(app1.get_id(), node->get_discovery_info().id());
@@ -420,7 +420,7 @@ CASE_TEST(atapp_etcd_module, discovery_registration) {
 
   // Also verify by_name lookup works
   {
-    auto node_by_name = etcd_mod1->get_global_discovery().get_node_by_name(app2.get_app_name());
+    auto node_by_name = discovery_module1->get_global_discovery().get_node_by_name(app2.get_app_name());
     CASE_EXPECT_TRUE(!!node_by_name);
     if (node_by_name) {
       CASE_EXPECT_EQ(app2.get_app_name(), node_by_name->get_discovery_info().name());
@@ -453,20 +453,20 @@ CASE_TEST(atapp_etcd_module, discovery_event_callback) {
   const char *args1[] = {"app1", "-c", conf_path_1.c_str(), "start"};
   CASE_EXPECT_EQ(0, app1.init(nullptr, 4, args1, nullptr));
 
-  auto etcd_mod1 = app1.get_etcd_module();
-  CASE_EXPECT_TRUE(!!etcd_mod1);
-  if (!etcd_mod1) {
+  auto discovery_module1 = app1.get_service_discovery_module();
+  CASE_EXPECT_TRUE(!!discovery_module1);
+  if (!discovery_module1) {
     return;
   }
 
   // Register discovery event callback on node1
   int discovery_callback_count = 0;
   atapp::etcd_discovery_node::ptr_t last_discovery_node;
-  atapp::etcd_module::node_action_t last_action = atapp::etcd_module::node_action_t::kUnknown;
+  atapp::service_discovery_module::node_action_t last_action = atapp::service_discovery_module::node_action_t::kUnknown;
 
-  auto handle = etcd_mod1->add_on_node_discovery_event(
-      [&discovery_callback_count, &last_discovery_node, &last_action](atapp::etcd_module::node_action_t action,
-                                                                      const atapp::etcd_discovery_node::ptr_t &node) {
+  auto handle = discovery_module1->add_on_node_discovery_event(
+      [&discovery_callback_count, &last_discovery_node, &last_action](
+          atapp::service_discovery_module::node_action_t action, const atapp::etcd_discovery_node::ptr_t &node) {
         ++discovery_callback_count;
         last_action = action;
         last_discovery_node = node;
@@ -474,12 +474,12 @@ CASE_TEST(atapp_etcd_module, discovery_event_callback) {
 
   // Wait for snapshot to complete first
   std::vector<atframework::atapp::app *> apps1 = {&app1};
-  run_apps_until(apps1, [&etcd_mod1]() { return etcd_mod1->has_discovery_snapshot(); });
+  run_apps_until(apps1, [&discovery_module1]() { return discovery_module1->has_discovery_snapshot(); });
 
   // Reset after snapshot to ignore self-registration events
   int baseline_discovery = discovery_callback_count;
   last_discovery_node.reset();
-  last_action = atapp::etcd_module::node_action_t::kUnknown;
+  last_action = atapp::service_discovery_module::node_action_t::kUnknown;
 
   // Now start node2
   atframework::atapp::app app2;
@@ -497,7 +497,7 @@ CASE_TEST(atapp_etcd_module, discovery_event_callback) {
   CASE_EXPECT_GT(discovery_callback_count, baseline_discovery);
   CASE_EXPECT_TRUE(!!last_discovery_node);
   // Verify action is kPut (new node registration), not kDelete
-  CASE_EXPECT_EQ(static_cast<int>(atapp::etcd_module::node_action_t::kPut), static_cast<int>(last_action));
+  CASE_EXPECT_EQ(static_cast<int>(atapp::service_discovery_module::node_action_t::kPut), static_cast<int>(last_action));
 
   if (last_discovery_node) {
     // Verify the discovered node's data matches app2
@@ -511,7 +511,7 @@ CASE_TEST(atapp_etcd_module, discovery_event_callback) {
   }
 
   // Cleanup
-  etcd_mod1->remove_on_node_event(handle);
+  discovery_module1->remove_on_node_event(handle);
 }
 
 // ============================================================
@@ -538,34 +538,34 @@ CASE_TEST(atapp_etcd_module, discovery_event_remove_callback) {
   const char *args1[] = {"app1", "-c", conf_path_1.c_str(), "start"};
   CASE_EXPECT_EQ(0, app1.init(nullptr, 4, args1, nullptr));
 
-  auto etcd_mod1 = app1.get_etcd_module();
-  CASE_EXPECT_TRUE(!!etcd_mod1);
-  if (!etcd_mod1) {
+  auto discovery_module1 = app1.get_service_discovery_module();
+  CASE_EXPECT_TRUE(!!discovery_module1);
+  if (!discovery_module1) {
     return;
   }
 
   // Register and immediately remove the callback
   int removed_callback_count = 0;
-  auto handle = etcd_mod1->add_on_node_discovery_event(
-      [&removed_callback_count](atapp::etcd_module::node_action_t, const atapp::etcd_discovery_node::ptr_t &) {
-        ++removed_callback_count;
-      });
+  auto handle = discovery_module1->add_on_node_discovery_event(
+      [&removed_callback_count](atapp::service_discovery_module::node_action_t,
+                                const atapp::etcd_discovery_node::ptr_t &) { ++removed_callback_count; });
 
-  etcd_mod1->remove_on_node_event(handle);
+  discovery_module1->remove_on_node_event(handle);
   int removed_baseline = removed_callback_count;
 
   // Register a second callback that should still fire (only count kPut to avoid kDelete noise)
   int active_callback_count = 0;
-  auto active_handle = etcd_mod1->add_on_node_discovery_event(
-      [&active_callback_count](atapp::etcd_module::node_action_t action, const atapp::etcd_discovery_node::ptr_t &) {
-        if (action == atapp::etcd_module::node_action_t::kPut) {
+  auto active_handle = discovery_module1->add_on_node_discovery_event(
+      [&active_callback_count](atapp::service_discovery_module::node_action_t action,
+                               const atapp::etcd_discovery_node::ptr_t &) {
+        if (action == atapp::service_discovery_module::node_action_t::kPut) {
           ++active_callback_count;
         }
       });
 
   // Wait for snapshot, then start node2
   std::vector<atframework::atapp::app *> apps1 = {&app1};
-  run_apps_until(apps1, [&etcd_mod1]() { return etcd_mod1->has_discovery_snapshot(); });
+  run_apps_until(apps1, [&discovery_module1]() { return discovery_module1->has_discovery_snapshot(); });
 
   atframework::atapp::app app2;
   const char *args2[] = {"app2", "-c", conf_path_2.c_str(), "start"};
@@ -583,7 +583,7 @@ CASE_TEST(atapp_etcd_module, discovery_event_remove_callback) {
                   << ", active_callback_count: " << active_callback_count << '\n';
 
   // Cleanup
-  etcd_mod1->remove_on_node_event(active_handle);
+  discovery_module1->remove_on_node_event(active_handle);
 }
 
 // ============================================================
@@ -610,9 +610,9 @@ CASE_TEST(atapp_etcd_module, discovery_event_multi_callbacks) {
   const char *args1[] = {"app1", "-c", conf_path_1.c_str(), "start"};
   CASE_EXPECT_EQ(0, app1.init(nullptr, 4, args1, nullptr));
 
-  auto etcd_mod1 = app1.get_etcd_module();
-  CASE_EXPECT_TRUE(!!etcd_mod1);
-  if (!etcd_mod1) {
+  auto discovery_module1 = app1.get_service_discovery_module();
+  CASE_EXPECT_TRUE(!!discovery_module1);
+  if (!discovery_module1) {
     return;
   }
 
@@ -623,34 +623,36 @@ CASE_TEST(atapp_etcd_module, discovery_event_multi_callbacks) {
   int cb3_count = 0;
   atapp::etcd_discovery_node::ptr_t last_cb1_node;
 
-  auto h1 = etcd_mod1->add_on_node_discovery_event(
-      [&cb1_count, &call_order, &last_cb1_node](atapp::etcd_module::node_action_t action,
+  auto h1 = discovery_module1->add_on_node_discovery_event(
+      [&cb1_count, &call_order, &last_cb1_node](atapp::service_discovery_module::node_action_t action,
                                                 const atapp::etcd_discovery_node::ptr_t &node) {
-        if (action == atapp::etcd_module::node_action_t::kPut) {
+        if (action == atapp::service_discovery_module::node_action_t::kPut) {
           ++cb1_count;
           call_order.push_back(1);
           last_cb1_node = node;
         }
       });
 
-  auto h2 = etcd_mod1->add_on_node_discovery_event(
-      [&cb2_count, &call_order](atapp::etcd_module::node_action_t action, const atapp::etcd_discovery_node::ptr_t &) {
-        if (action == atapp::etcd_module::node_action_t::kPut) {
+  auto h2 = discovery_module1->add_on_node_discovery_event(
+      [&cb2_count, &call_order](atapp::service_discovery_module::node_action_t action,
+                                const atapp::etcd_discovery_node::ptr_t &) {
+        if (action == atapp::service_discovery_module::node_action_t::kPut) {
           ++cb2_count;
           call_order.push_back(2);
         }
       });
 
-  auto h3 = etcd_mod1->add_on_node_discovery_event(
-      [&cb3_count, &call_order](atapp::etcd_module::node_action_t action, const atapp::etcd_discovery_node::ptr_t &) {
-        if (action == atapp::etcd_module::node_action_t::kPut) {
+  auto h3 = discovery_module1->add_on_node_discovery_event(
+      [&cb3_count, &call_order](atapp::service_discovery_module::node_action_t action,
+                                const atapp::etcd_discovery_node::ptr_t &) {
+        if (action == atapp::service_discovery_module::node_action_t::kPut) {
           ++cb3_count;
           call_order.push_back(3);
         }
       });
 
   std::vector<atframework::atapp::app *> apps1 = {&app1};
-  run_apps_until(apps1, [&etcd_mod1]() { return etcd_mod1->has_discovery_snapshot(); });
+  run_apps_until(apps1, [&discovery_module1]() { return discovery_module1->has_discovery_snapshot(); });
 
   atframework::atapp::app app2;
   const char *args2[] = {"app2", "-c", conf_path_2.c_str(), "start"};
@@ -683,9 +685,9 @@ CASE_TEST(atapp_etcd_module, discovery_event_multi_callbacks) {
   }
 
   // Cleanup
-  etcd_mod1->remove_on_node_event(h1);
-  etcd_mod1->remove_on_node_event(h2);
-  etcd_mod1->remove_on_node_event(h3);
+  discovery_module1->remove_on_node_event(h1);
+  discovery_module1->remove_on_node_event(h2);
+  discovery_module1->remove_on_node_event(h3);
 }
 
 // ============================================================
@@ -712,31 +714,33 @@ CASE_TEST(atapp_etcd_module, topology_event_callback) {
   const char *args1[] = {"app1", "-c", conf_path_1.c_str(), "start"};
   CASE_EXPECT_EQ(0, app1.init(nullptr, 4, args1, nullptr));
 
-  auto etcd_mod1 = app1.get_etcd_module();
-  CASE_EXPECT_TRUE(!!etcd_mod1);
-  if (!etcd_mod1) {
+  auto discovery_module1 = app1.get_service_discovery_module();
+  CASE_EXPECT_TRUE(!!discovery_module1);
+  if (!discovery_module1) {
     return;
   }
 
   // Register topology event callback
   int topology_callback_count = 0;
-  atapp::etcd_module::atapp_topology_info_ptr_t last_topology_info;
-  atapp::etcd_module::topology_action_t last_topology_action = atapp::etcd_watch_event::kDelete;
+  atapp::service_discovery_module::atapp_topology_info_ptr_t last_topology_info;
+  atapp::service_discovery_module::topology_action_t last_topology_action = atapp::etcd_watch_event::kDelete;
   atapp::etcd_data_version last_version{};
+  std::list<uint64_t> topology_id_history;
 
-  auto handle = etcd_mod1->add_on_topology_info_event(
-      [&topology_callback_count, &last_topology_info, &last_topology_action, &last_version](
-          atapp::etcd_module::topology_action_t action, const atapp::etcd_module::atapp_topology_info_ptr_t &info,
-          const atapp::etcd_data_version &ver) {
+  auto handle = discovery_module1->add_on_topology_info_event(
+      [&topology_callback_count, &last_topology_info, &last_topology_action, &last_version, &topology_id_history](
+          atapp::service_discovery_module::topology_action_t action,
+          const atapp::service_discovery_module::atapp_topology_info_ptr_t &info, const atapp::etcd_data_version &ver) {
         ++topology_callback_count;
         last_topology_action = action;
         last_topology_info = info;
         last_version = ver;
+        topology_id_history.push_back(info ? info->id() : 0);
       });
 
   // Wait for snapshot to load
   std::vector<atframework::atapp::app *> apps1 = {&app1};
-  run_apps_until(apps1, [&etcd_mod1]() { return etcd_mod1->has_topology_snapshot(); });
+  run_apps_until(apps1, [&discovery_module1]() { return discovery_module1->has_topology_snapshot(); });
 
   // Record baseline count (self-registration may fire)
   int baseline_count = topology_callback_count;
@@ -765,10 +769,13 @@ CASE_TEST(atapp_etcd_module, topology_event_callback) {
                     << " id=" << last_topology_info->id() << " name=" << last_topology_info->name()
                     << " version.create_revision=" << last_version.create_revision
                     << " version.modify_revision=" << last_version.modify_revision << '\n';
+    for (const auto &id : topology_id_history) {
+      CASE_MSG_INFO() << "topology id in callback history: " << id << '\n';
+    }
   }
 
   // Cleanup
-  etcd_mod1->remove_on_topology_info_event(handle);
+  discovery_module1->remove_on_topology_info_event(handle);
 }
 
 // ============================================================
@@ -795,27 +802,27 @@ CASE_TEST(atapp_etcd_module, topology_event_remove_callback) {
   const char *args1[] = {"app1", "-c", conf_path_1.c_str(), "start"};
   CASE_EXPECT_EQ(0, app1.init(nullptr, 4, args1, nullptr));
 
-  auto etcd_mod1 = app1.get_etcd_module();
-  CASE_EXPECT_TRUE(!!etcd_mod1);
-  if (!etcd_mod1) {
+  auto discovery_module1 = app1.get_service_discovery_module();
+  CASE_EXPECT_TRUE(!!discovery_module1);
+  if (!discovery_module1) {
     return;
   }
 
   // Register and remove topology callback
   int removed_callback_count = 0;
-  auto removed_handle = etcd_mod1->add_on_topology_info_event(
-      [&removed_callback_count](atapp::etcd_module::topology_action_t,
-                                const atapp::etcd_module::atapp_topology_info_ptr_t &,
+  auto removed_handle = discovery_module1->add_on_topology_info_event(
+      [&removed_callback_count](atapp::service_discovery_module::topology_action_t,
+                                const atapp::service_discovery_module::atapp_topology_info_ptr_t &,
                                 const atapp::etcd_data_version &) { ++removed_callback_count; });
 
-  etcd_mod1->remove_on_topology_info_event(removed_handle);
+  discovery_module1->remove_on_topology_info_event(removed_handle);
   int removed_baseline = removed_callback_count;
 
   // Register active callback (only count kPut to avoid kDelete noise)
   int active_callback_count = 0;
-  auto active_handle = etcd_mod1->add_on_topology_info_event(
-      [&active_callback_count](atapp::etcd_module::topology_action_t action,
-                               const atapp::etcd_module::atapp_topology_info_ptr_t &,
+  auto active_handle = discovery_module1->add_on_topology_info_event(
+      [&active_callback_count](atapp::service_discovery_module::topology_action_t action,
+                               const atapp::service_discovery_module::atapp_topology_info_ptr_t &,
                                const atapp::etcd_data_version &) {
         if (action == atapp::etcd_watch_event::kPut) {
           ++active_callback_count;
@@ -824,7 +831,7 @@ CASE_TEST(atapp_etcd_module, topology_event_remove_callback) {
 
   // Wait for snapshot
   std::vector<atframework::atapp::app *> apps1 = {&app1};
-  run_apps_until(apps1, [&etcd_mod1]() { return etcd_mod1->has_topology_snapshot(); });
+  run_apps_until(apps1, [&discovery_module1]() { return discovery_module1->has_topology_snapshot(); });
 
   int baseline_active = active_callback_count;
 
@@ -845,7 +852,7 @@ CASE_TEST(atapp_etcd_module, topology_event_remove_callback) {
                   << ", active_topology_callback_count: " << active_callback_count << '\n';
 
   // Cleanup
-  etcd_mod1->remove_on_topology_info_event(active_handle);
+  discovery_module1->remove_on_topology_info_event(active_handle);
 }
 
 // ============================================================
@@ -872,22 +879,22 @@ CASE_TEST(atapp_etcd_module, topology_event_multi_callbacks) {
   const char *args1[] = {"app1", "-c", conf_path_1.c_str(), "start"};
   CASE_EXPECT_EQ(0, app1.init(nullptr, 4, args1, nullptr));
 
-  auto etcd_mod1 = app1.get_etcd_module();
-  CASE_EXPECT_TRUE(!!etcd_mod1);
-  if (!etcd_mod1) {
+  auto discovery_module1 = app1.get_service_discovery_module();
+  CASE_EXPECT_TRUE(!!discovery_module1);
+  if (!discovery_module1) {
     return;
   }
 
   // Register multiple topology callbacks (only count kPut events)
   int cb1_count = 0;
   int cb2_count = 0;
-  atapp::etcd_module::atapp_topology_info_ptr_t last_cb1_info;
+  atapp::service_discovery_module::atapp_topology_info_ptr_t last_cb1_info;
   atapp::etcd_data_version last_cb1_version{};
 
-  auto h1 = etcd_mod1->add_on_topology_info_event(
-      [&cb1_count, &last_cb1_info, &last_cb1_version](atapp::etcd_module::topology_action_t action,
-                                                      const atapp::etcd_module::atapp_topology_info_ptr_t &info,
-                                                      const atapp::etcd_data_version &ver) {
+  auto h1 = discovery_module1->add_on_topology_info_event(
+      [&cb1_count, &last_cb1_info, &last_cb1_version](
+          atapp::service_discovery_module::topology_action_t action,
+          const atapp::service_discovery_module::atapp_topology_info_ptr_t &info, const atapp::etcd_data_version &ver) {
         if (action == atapp::etcd_watch_event::kPut) {
           ++cb1_count;
           last_cb1_info = info;
@@ -895,17 +902,18 @@ CASE_TEST(atapp_etcd_module, topology_event_multi_callbacks) {
         }
       });
 
-  auto h2 = etcd_mod1->add_on_topology_info_event([&cb2_count](atapp::etcd_module::topology_action_t action,
-                                                               const atapp::etcd_module::atapp_topology_info_ptr_t &,
-                                                               const atapp::etcd_data_version &) {
-    if (action == atapp::etcd_watch_event::kPut) {
-      ++cb2_count;
-    }
-  });
+  auto h2 = discovery_module1->add_on_topology_info_event(
+      [&cb2_count](atapp::service_discovery_module::topology_action_t action,
+                   const atapp::service_discovery_module::atapp_topology_info_ptr_t &,
+                   const atapp::etcd_data_version &) {
+        if (action == atapp::etcd_watch_event::kPut) {
+          ++cb2_count;
+        }
+      });
 
   // Wait for snapshot
   std::vector<atframework::atapp::app *> apps1 = {&app1};
-  run_apps_until(apps1, [&etcd_mod1]() { return etcd_mod1->has_topology_snapshot(); });
+  run_apps_until(apps1, [&discovery_module1]() { return discovery_module1->has_topology_snapshot(); });
 
   int baseline1 = cb1_count;
   int baseline2 = cb2_count;
@@ -937,8 +945,8 @@ CASE_TEST(atapp_etcd_module, topology_event_multi_callbacks) {
                   << '\n';
 
   // Cleanup
-  etcd_mod1->remove_on_topology_info_event(h1);
-  etcd_mod1->remove_on_topology_info_event(h2);
+  discovery_module1->remove_on_topology_info_event(h1);
+  discovery_module1->remove_on_topology_info_event(h2);
 }
 
 // ============================================================
@@ -968,25 +976,25 @@ CASE_TEST(atapp_etcd_module, multi_node_topology_update) {
   CASE_EXPECT_EQ(0, app1.init(nullptr, 4, args1, nullptr));
   CASE_EXPECT_EQ(0, app2.init(nullptr, 4, args2, nullptr));
 
-  auto etcd_mod1 = app1.get_etcd_module();
-  auto etcd_mod2 = app2.get_etcd_module();
-  CASE_EXPECT_TRUE(!!etcd_mod1);
-  CASE_EXPECT_TRUE(!!etcd_mod2);
-  if (!etcd_mod1 || !etcd_mod2) {
+  auto discovery_module1 = app1.get_service_discovery_module();
+  auto discovery_module2 = app2.get_service_discovery_module();
+  CASE_EXPECT_TRUE(!!discovery_module1);
+  CASE_EXPECT_TRUE(!!discovery_module2);
+  if (!discovery_module1 || !discovery_module2) {
     return;
   }
 
   std::vector<atframework::atapp::app *> apps = {&app1, &app2};
 
   // Wait for node1 to see node2's topology
-  bool node1_has_node2_topo = run_apps_until(apps, [&etcd_mod1, &app2]() {
-    const auto &topo = etcd_mod1->get_topology_info_set();
+  bool node1_has_node2_topo = run_apps_until(apps, [&discovery_module1, &app2]() {
+    const auto &topo = discovery_module1->get_topology_info_set();
     return topo.find(app2.get_id()) != topo.end();
   });
 
   CASE_EXPECT_TRUE(node1_has_node2_topo);
   if (node1_has_node2_topo) {
-    const auto &topo = etcd_mod1->get_topology_info_set();
+    const auto &topo = discovery_module1->get_topology_info_set();
     auto it = topo.find(app2.get_id());
     CASE_EXPECT_TRUE(it != topo.end());
     if (it != topo.end() && it->second.info) {
@@ -996,14 +1004,14 @@ CASE_TEST(atapp_etcd_module, multi_node_topology_update) {
   }
 
   // Check node2 sees node1's topology
-  bool node2_has_node1_topo = run_apps_until(apps, [&etcd_mod2, &app1]() {
-    const auto &topo = etcd_mod2->get_topology_info_set();
+  bool node2_has_node1_topo = run_apps_until(apps, [&discovery_module2, &app1]() {
+    const auto &topo = discovery_module2->get_topology_info_set();
     return topo.find(app1.get_id()) != topo.end();
   });
 
   CASE_EXPECT_TRUE(node2_has_node1_topo);
   if (node2_has_node1_topo) {
-    const auto &topo = etcd_mod2->get_topology_info_set();
+    const auto &topo = discovery_module2->get_topology_info_set();
     auto it = topo.find(app1.get_id());
     CASE_EXPECT_TRUE(it != topo.end());
     if (it != topo.end() && it->second.info) {
@@ -1037,33 +1045,31 @@ CASE_TEST(atapp_etcd_module, discovery_event_delete) {
   const char *args1[] = {"app1", "-c", conf_path_1.c_str(), "start"};
   CASE_EXPECT_EQ(0, app1.init(nullptr, 4, args1, nullptr));
 
-  auto etcd_mod1 = app1.get_etcd_module();
-  CASE_EXPECT_TRUE(!!etcd_mod1);
-  if (!etcd_mod1) {
+  auto discovery_module1 = app1.get_service_discovery_module();
+  CASE_EXPECT_TRUE(!!discovery_module1);
+  if (!discovery_module1) {
     return;
   }
 
   // Track discovery events
   int put_count = 0;
   int delete_count = 0;
-  atapp::etcd_module::node_action_t last_action = atapp::etcd_module::node_action_t::kUnknown;
+  atapp::service_discovery_module::node_action_t last_action = atapp::service_discovery_module::node_action_t::kUnknown;
   atapp::etcd_discovery_node::ptr_t last_delete_node;
   // Track app2-specific put event to avoid self-registration/refresh noise
-  uint64_t app2_id = 0;
   std::string app2_name;
-  bool got_app2_put = false;
-  atapp::etcd_discovery_node::ptr_t app2_put_node;
+  uint64_t app2_id = 0;
+  std::map<uint64_t, atapp::etcd_discovery_node::ptr_t> id_node_map;
 
-  auto handle = etcd_mod1->add_on_node_discovery_event(
-      [&](atapp::etcd_module::node_action_t action, const atapp::etcd_discovery_node::ptr_t &node) {
+  auto handle = discovery_module1->add_on_node_discovery_event(
+      [&](atapp::service_discovery_module::node_action_t action, const atapp::etcd_discovery_node::ptr_t &node) {
         last_action = action;
-        if (action == atapp::etcd_module::node_action_t::kPut) {
+        if (action == atapp::service_discovery_module::node_action_t::kPut) {
           ++put_count;
-          if (node && app2_id != 0 && node->get_discovery_info().id() == app2_id) {
-            got_app2_put = true;
-            app2_put_node = node;
+          if (node) {
+            id_node_map[node->get_discovery_info().id()] = node;
           }
-        } else if (action == atapp::etcd_module::node_action_t::kDelete) {
+        } else if (action == atapp::service_discovery_module::node_action_t::kDelete) {
           ++delete_count;
           last_delete_node = node;
         }
@@ -1071,7 +1077,7 @@ CASE_TEST(atapp_etcd_module, discovery_event_delete) {
 
   // Wait for snapshot on node1
   std::vector<atframework::atapp::app *> apps1 = {&app1};
-  run_apps_until(apps1, [&etcd_mod1]() { return etcd_mod1->has_discovery_snapshot(); });
+  run_apps_until(apps1, [&discovery_module1]() { return discovery_module1->has_discovery_snapshot(); });
 
   // Start node2 and wait for kPut event for app2 specifically
   {
@@ -1081,26 +1087,26 @@ CASE_TEST(atapp_etcd_module, discovery_event_delete) {
     app2_id = app2.get_id();
     app2_name = app2.get_app_name();
 
-    auto etcd_mod2 = app2.get_etcd_module();
-    CASE_EXPECT_TRUE(!!etcd_mod2);
-    if (!etcd_mod2) {
-      etcd_mod1->remove_on_node_event(handle);
+    auto discovery_module2 = app2.get_service_discovery_module();
+    CASE_EXPECT_TRUE(!!discovery_module2);
+    if (!discovery_module2) {
+      discovery_module1->remove_on_node_event(handle);
       return;
     }
 
     std::vector<atframework::atapp::app *> apps = {&app1, &app2};
-    bool got_put = run_apps_until(apps, [&got_app2_put]() { return got_app2_put; });
+    bool got_put = run_apps_until(apps, [&id_node_map, app2_id]() { return id_node_map.count(app2_id) > 0; });
     CASE_EXPECT_TRUE(got_put);
     // Verify the put event contains node2's data
-    CASE_EXPECT_TRUE(!!app2_put_node);
-    if (app2_put_node) {
-      CASE_EXPECT_EQ(app2_id, app2_put_node->get_discovery_info().id());
-      CASE_EXPECT_EQ(app2_name, app2_put_node->get_discovery_info().name());
+    CASE_EXPECT_TRUE(!!(id_node_map.count(app2_id) > 0));
+    if (id_node_map.count(app2_id) > 0) {
+      CASE_EXPECT_EQ(app2_id, id_node_map[app2_id]->get_discovery_info().id());
+      CASE_EXPECT_EQ(app2_name, id_node_map[app2_id]->get_discovery_info().name());
     }
     CASE_MSG_INFO() << "discovery_event_delete: got kPut, put_count=" << put_count << '\n';
 
     // Now stop node2's etcd module to revoke its lease, triggering kDelete
-    etcd_mod2->stop();
+    discovery_module2->stop();
 
     // Tick both apps to process the close/revoke HTTP request
     run_apps_noblock(apps, 30);
@@ -1113,7 +1119,8 @@ CASE_TEST(atapp_etcd_module, discovery_event_delete) {
   CASE_EXPECT_TRUE(got_delete);
   CASE_EXPECT_GT(delete_count, 0);
   // Verify the last action was indeed kDelete, not kPut
-  CASE_EXPECT_EQ(static_cast<int>(atapp::etcd_module::node_action_t::kDelete), static_cast<int>(last_action));
+  CASE_EXPECT_EQ(static_cast<int>(atapp::service_discovery_module::node_action_t::kDelete),
+                 static_cast<int>(last_action));
   // Verify the deleted node's identity matches app2
   CASE_EXPECT_TRUE(!!last_delete_node);
   if (last_delete_node) {
@@ -1123,7 +1130,7 @@ CASE_TEST(atapp_etcd_module, discovery_event_delete) {
                   << " last_action=" << static_cast<int>(last_action) << '\n';
 
   // Cleanup
-  etcd_mod1->remove_on_node_event(handle);
+  discovery_module1->remove_on_node_event(handle);
 }
 
 // ============================================================
@@ -1150,42 +1157,40 @@ CASE_TEST(atapp_etcd_module, topology_event_delete) {
   const char *args1[] = {"app1", "-c", conf_path_1.c_str(), "start"};
   CASE_EXPECT_EQ(0, app1.init(nullptr, 4, args1, nullptr));
 
-  auto etcd_mod1 = app1.get_etcd_module();
-  CASE_EXPECT_TRUE(!!etcd_mod1);
-  if (!etcd_mod1) {
+  auto discovery_module1 = app1.get_service_discovery_module();
+  CASE_EXPECT_TRUE(!!discovery_module1);
+  if (!discovery_module1) {
     return;
   }
 
   // Track topology events
   int put_count = 0;
   int delete_count = 0;
-  atapp::etcd_module::topology_action_t last_topo_action = atapp::etcd_watch_event::kPut;
-  atapp::etcd_module::atapp_topology_info_ptr_t last_delete_info;
+  atapp::service_discovery_module::topology_action_t last_topo_action = atapp::etcd_watch_event::kPut;
+  atapp::service_discovery_module::atapp_topology_info_ptr_t last_delete_info;
   // Track app2-specific put event to avoid self-registration/refresh noise
-  uint64_t app2_id = 0;
   std::string app2_name;
-  bool got_app2_topo_put = false;
-  atapp::etcd_module::atapp_topology_info_ptr_t app2_put_info;
-
-  auto handle = etcd_mod1->add_on_topology_info_event([&](atapp::etcd_module::topology_action_t action,
-                                                          const atapp::etcd_module::atapp_topology_info_ptr_t &info,
-                                                          const atapp::etcd_data_version &) {
-    last_topo_action = action;
-    if (action == atapp::etcd_watch_event::kPut) {
-      ++put_count;
-      if (info && app2_id != 0 && info->id() == app2_id) {
-        got_app2_topo_put = true;
-        app2_put_info = info;
-      }
-    } else if (action == atapp::etcd_watch_event::kDelete) {
-      ++delete_count;
-      last_delete_info = info;
-    }
-  });
+  uint64_t app2_id = 0;
+  std::map<uint64_t, atapp::service_discovery_module::atapp_topology_info_ptr_t> topo_info_set;
+
+  auto handle = discovery_module1->add_on_topology_info_event(
+      [&](atapp::service_discovery_module::topology_action_t action,
+          const atapp::service_discovery_module::atapp_topology_info_ptr_t &info, const atapp::etcd_data_version &) {
+        last_topo_action = action;
+        if (action == atapp::etcd_watch_event::kPut) {
+          ++put_count;
+          if (info) {
+            topo_info_set[info->id()] = info;
+          }
+        } else if (action == atapp::etcd_watch_event::kDelete) {
+          ++delete_count;
+          last_delete_info = info;
+        }
+      });
 
   // Wait for snapshot on node1
   std::vector<atframework::atapp::app *> apps1 = {&app1};
-  run_apps_until(apps1, [&etcd_mod1]() { return etcd_mod1->has_topology_snapshot(); });
+  run_apps_until(apps1, [&discovery_module1]() { return discovery_module1->has_topology_snapshot(); });
 
   // Start node2 and wait for kPut event for app2 specifically
   {
@@ -1195,26 +1200,26 @@ CASE_TEST(atapp_etcd_module, topology_event_delete) {
     app2_id = app2.get_id();
     app2_name = app2.get_app_name();
 
-    auto etcd_mod2 = app2.get_etcd_module();
-    CASE_EXPECT_TRUE(!!etcd_mod2);
-    if (!etcd_mod2) {
-      etcd_mod1->remove_on_topology_info_event(handle);
+    auto discovery_module2 = app2.get_service_discovery_module();
+    CASE_EXPECT_TRUE(!!discovery_module2);
+    if (!discovery_module2) {
+      discovery_module1->remove_on_topology_info_event(handle);
       return;
     }
 
     std::vector<atframework::atapp::app *> apps = {&app1, &app2};
-    bool got_put = run_apps_until(apps, [&got_app2_topo_put]() { return got_app2_topo_put; });
+    bool got_put = run_apps_until(apps, [&topo_info_set, &app2_id]() { return topo_info_set.count(app2_id) > 0; });
     CASE_EXPECT_TRUE(got_put);
     // Verify the put event contains node2's data
-    CASE_EXPECT_TRUE(!!app2_put_info);
-    if (app2_put_info) {
-      CASE_EXPECT_EQ(app2_id, app2_put_info->id());
-      CASE_EXPECT_EQ(app2_name, app2_put_info->name());
+    CASE_EXPECT_TRUE(!!(topo_info_set.count(app2_id) > 0));
+    if (topo_info_set.count(app2_id) > 0) {
+      CASE_EXPECT_EQ(app2_id, topo_info_set[app2_id]->id());
+      CASE_EXPECT_EQ(app2_name, topo_info_set[app2_id]->name());
     }
     CASE_MSG_INFO() << "topology_event_delete: got kPut, put_count=" << put_count << '\n';
 
     // Stop node2's etcd module to revoke its lease
-    etcd_mod2->stop();
+    discovery_module2->stop();
     run_apps_noblock(apps, 30);
   }
 
@@ -1234,7 +1239,7 @@ CASE_TEST(atapp_etcd_module, topology_event_delete) {
                   << " last_action=" << static_cast<int>(last_topo_action) << '\n';
 
   // Cleanup
-  etcd_mod1->remove_on_topology_info_event(handle);
+  discovery_module1->remove_on_topology_info_event(handle);
 }
 
 // ============================================================
@@ -1259,36 +1264,36 @@ CASE_TEST(atapp_etcd_module, stop_revoke_lease) {
   const char *args[] = {"app", "-c", conf_path.c_str(), "start"};
   CASE_EXPECT_EQ(0, app.init(nullptr, 4, args, nullptr));
 
-  auto etcd_mod = app.get_etcd_module();
-  CASE_EXPECT_TRUE(!!etcd_mod);
-  if (!etcd_mod) {
+  auto discovery_mod = app.get_service_discovery_module();
+  CASE_EXPECT_TRUE(!!discovery_mod);
+  if (!discovery_mod) {
     return;
   }
 
   // Wait for module to be ready and get a lease
   std::vector<atframework::atapp::app *> apps = {&app};
-  bool ready = run_apps_until(apps, [&etcd_mod]() { return etcd_mod->get_raw_etcd_ctx().is_available(); });
+  bool ready = run_apps_until(apps, [&discovery_mod]() { return discovery_mod->get_raw_etcd_ctx().is_available(); });
   CASE_EXPECT_TRUE(ready);
 
-  int64_t lease_before = etcd_mod->get_raw_etcd_ctx().get_lease();
+  int64_t lease_before = discovery_mod->get_raw_etcd_ctx().get_lease();
   CASE_EXPECT_NE(0, lease_before);
   CASE_MSG_INFO() << "stop_revoke_lease: lease before stop = " << lease_before << '\n';
 
   // Stop the etcd module - this should revoke the lease
-  etcd_mod->stop();
+  discovery_mod->stop();
 
   // Tick to process the close/revoke request
   bool stopped = run_apps_until(
       apps,
-      [&etcd_mod]() {
+      [&discovery_mod]() {
         // After stop completes, the context should no longer be available
-        return !etcd_mod->get_raw_etcd_ctx().is_available();
+        return !discovery_mod->get_raw_etcd_ctx().is_available();
       },
       std::chrono::seconds(10));
 
   CASE_EXPECT_TRUE(stopped);
   CASE_MSG_INFO() << "stop_revoke_lease: etcd ctx available after stop = "
-                  << (etcd_mod->get_raw_etcd_ctx().is_available() ? "true" : "false") << '\n';
+                  << (discovery_mod->get_raw_etcd_ctx().is_available() ? "true" : "false") << '\n';
 }
 
 // ============================================================
@@ -1315,53 +1320,52 @@ CASE_TEST(atapp_etcd_module, multi_node_discovery_put_event) {
   const char *args1[] = {"app1", "-c", conf_path_1.c_str(), "start"};
   CASE_EXPECT_EQ(0, app1.init(nullptr, 4, args1, nullptr));
 
-  auto etcd_mod1 = app1.get_etcd_module();
-  CASE_EXPECT_TRUE(!!etcd_mod1);
-  if (!etcd_mod1) {
+  auto discovery_module1 = app1.get_service_discovery_module();
+  CASE_EXPECT_TRUE(!!discovery_module1);
+  if (!discovery_module1) {
     return;
   }
 
   // Wait for snapshot
   std::vector<atframework::atapp::app *> apps1 = {&app1};
-  run_apps_until(apps1, [&etcd_mod1]() { return etcd_mod1->has_discovery_snapshot(); });
-
-  // Start node2
-  atframework::atapp::app app2;
-  const char *args2[] = {"app2", "-c", conf_path_2.c_str(), "start"};
-  CASE_EXPECT_EQ(0, app2.init(nullptr, 4, args2, nullptr));
+  run_apps_until(apps1, [&discovery_module1]() { return discovery_module1->has_discovery_snapshot(); });
 
   // Register callback to track kPut events specifically for node2's ID
-  uint64_t target_id = app2.get_id();
-  bool got_node2_put = false;
+  uint64_t target_id = 0;
+  std::set<uint64_t> got_put_id;
   int put_event_count = 0;
-  auto handle = etcd_mod1->add_on_node_discovery_event(
-      [&got_node2_put, &put_event_count, target_id](atapp::etcd_module::node_action_t action,
-                                                    const atapp::etcd_discovery_node::ptr_t &node) {
-        if (action == atapp::etcd_module::node_action_t::kPut && node) {
+  auto handle = discovery_module1->add_on_node_discovery_event(
+      [&got_put_id, &put_event_count](atapp::service_discovery_module::node_action_t action,
+                                      const atapp::etcd_discovery_node::ptr_t &node) {
+        if (action == atapp::service_discovery_module::node_action_t::kPut && node) {
           ++put_event_count;
-          if (node->get_discovery_info().id() == target_id) {
-            got_node2_put = true;
-          }
+          got_put_id.insert(node->get_discovery_info().id());
         }
       });
 
+  // Start node2
+  atframework::atapp::app app2;
+  const char *args2[] = {"app2", "-c", conf_path_2.c_str(), "start"};
+  CASE_EXPECT_EQ(0, app2.init(nullptr, 4, args2, nullptr));
+  target_id = app2.get_id();
+
   std::vector<atframework::atapp::app *> apps = {&app1, &app2};
 
   // Wait for node1 to receive node2's discovery kPut event
-  bool success = run_apps_until(apps, [&got_node2_put]() { return got_node2_put; });
+  bool success = run_apps_until(apps, [&got_put_id, target_id]() { return got_put_id.count(target_id) > 0; });
   CASE_EXPECT_TRUE(success);
-  CASE_EXPECT_TRUE(got_node2_put);
+  CASE_EXPECT_TRUE(got_put_id.count(target_id) > 0);
   CASE_EXPECT_GT(put_event_count, 0);
 
   // Also verify global_discovery contains node2
-  auto node = etcd_mod1->get_global_discovery().get_node_by_id(app2.get_id());
+  auto node = discovery_module1->get_global_discovery().get_node_by_id(app2.get_id());
   CASE_EXPECT_TRUE(!!node);
 
   CASE_MSG_INFO() << "multi_node_discovery_put_event: put_count=" << put_event_count
-                  << " got_node2=" << (got_node2_put ? "true" : "false") << '\n';
+                  << " got_put_id=" << (got_put_id.count(target_id) > 0 ? "true" : "false") << '\n';
 
   // Cleanup
-  etcd_mod1->remove_on_node_event(handle);
+  discovery_module1->remove_on_node_event(handle);
 }
 
 // ============================================================
@@ -1388,9 +1392,9 @@ CASE_TEST(atapp_etcd_module, multi_node_discovery_delete_event) {
   const char *args1[] = {"app1", "-c", conf_path_1.c_str(), "start"};
   CASE_EXPECT_EQ(0, app1.init(nullptr, 4, args1, nullptr));
 
-  auto etcd_mod1 = app1.get_etcd_module();
-  CASE_EXPECT_TRUE(!!etcd_mod1);
-  if (!etcd_mod1) {
+  auto discovery_module1 = app1.get_service_discovery_module();
+  CASE_EXPECT_TRUE(!!discovery_module1);
+  if (!discovery_module1) {
     return;
   }
 
@@ -1399,10 +1403,10 @@ CASE_TEST(atapp_etcd_module, multi_node_discovery_delete_event) {
   // Register callback to verify we receive a kDelete action (not just node disappearing)
   int delete_event_count = 0;
   uint64_t delete_event_node_id = 0;
-  auto handle = etcd_mod1->add_on_node_discovery_event(
-      [&delete_event_count, &delete_event_node_id](atapp::etcd_module::node_action_t action,
+  auto handle = discovery_module1->add_on_node_discovery_event(
+      [&delete_event_count, &delete_event_node_id](atapp::service_discovery_module::node_action_t action,
                                                    const atapp::etcd_discovery_node::ptr_t &node) {
-        if (action == atapp::etcd_module::node_action_t::kDelete && node) {
+        if (action == atapp::service_discovery_module::node_action_t::kDelete && node) {
           ++delete_event_count;
           delete_event_node_id = node->get_discovery_info().id();
         }
@@ -1415,10 +1419,10 @@ CASE_TEST(atapp_etcd_module, multi_node_discovery_delete_event) {
     CASE_EXPECT_EQ(0, app2.init(nullptr, 4, args2, nullptr));
     app2_id = app2.get_id();
 
-    auto etcd_mod2 = app2.get_etcd_module();
-    CASE_EXPECT_TRUE(!!etcd_mod2);
-    if (!etcd_mod2) {
-      etcd_mod1->remove_on_node_event(handle);
+    auto discovery_module2 = app2.get_service_discovery_module();
+    CASE_EXPECT_TRUE(!!discovery_module2);
+    if (!discovery_module2) {
+      discovery_module1->remove_on_node_event(handle);
       return;
     }
 
@@ -1426,19 +1430,19 @@ CASE_TEST(atapp_etcd_module, multi_node_discovery_delete_event) {
 
     // Wait for node1 to discover node2
     bool found = run_apps_until(
-        apps, [&etcd_mod1, app2_id]() { return !!etcd_mod1->get_global_discovery().get_node_by_id(app2_id); });
+        apps, [&discovery_module1, app2_id]() { return !!discovery_module1->get_global_discovery().get_node_by_id(app2_id); });
     CASE_EXPECT_TRUE(found);
     CASE_MSG_INFO() << "multi_node_discovery_delete: node1 found node2, id=" << app2_id << '\n';
 
     // Stop node2's etcd module to revoke lease
-    etcd_mod2->stop();
+    discovery_module2->stop();
     run_apps_noblock(apps, 30);
   }
 
   // Continue ticking app1 - node2 should disappear from global_discovery
   std::vector<atframework::atapp::app *> apps1 = {&app1};
   bool node2_gone = run_apps_until(
-      apps1, [&etcd_mod1, app2_id]() { return !etcd_mod1->get_global_discovery().get_node_by_id(app2_id); },
+      apps1, [&discovery_module1, app2_id]() { return !discovery_module1->get_global_discovery().get_node_by_id(app2_id); },
       std::chrono::seconds(20));
 
   CASE_EXPECT_TRUE(node2_gone);
@@ -1451,7 +1455,7 @@ CASE_TEST(atapp_etcd_module, multi_node_discovery_delete_event) {
                   << " delete_node_id=" << delete_event_node_id << '\n';
 
   // Cleanup
-  etcd_mod1->remove_on_node_event(handle);
+  discovery_module1->remove_on_node_event(handle);
 }
 
 // ============================================================
@@ -1484,51 +1488,34 @@ CASE_TEST(atapp_etcd_module, multi_node_custom_data) {
   CASE_EXPECT_EQ(0, app1.init(nullptr, 4, args1, nullptr));
   CASE_EXPECT_EQ(0, app2.init(nullptr, 4, args2, nullptr));
 
-  auto etcd_mod1 = app1.get_etcd_module();
-  auto etcd_mod2 = app2.get_etcd_module();
-  CASE_EXPECT_TRUE(!!etcd_mod1);
-  CASE_EXPECT_TRUE(!!etcd_mod2);
-  if (!etcd_mod1 || !etcd_mod2) {
+  auto discovery1 = app1.get_service_discovery_module();
+  auto discovery2 = app2.get_service_discovery_module();
+  CASE_EXPECT_TRUE(!!discovery1);
+  CASE_EXPECT_TRUE(!!discovery2);
+  if (!discovery1 || !discovery2) {
     return;
   }
 
   std::vector<atframework::atapp::app *> apps = {&app1, &app2};
 
   // Wait for mutual discovery
-  bool mutual_discovery = run_apps_until(apps, [&etcd_mod1, &etcd_mod2, &app1, &app2]() {
-    return !!etcd_mod1->get_global_discovery().get_node_by_id(app2.get_id()) &&
-           !!etcd_mod2->get_global_discovery().get_node_by_id(app1.get_id());
+  bool mutual_discovery = run_apps_until(apps, [&discovery1, &discovery2, &app1, &app2]() {
+    return !!discovery1->get_global_discovery().get_node_by_id(app2.get_id()) &&
+           !!discovery2->get_global_discovery().get_node_by_id(app1.get_id());
   });
   CASE_EXPECT_TRUE(mutual_discovery);
 
-  // Verify set/get custom_data API works locally
-  const std::string custom_data_value = "test-custom-data-12345";
-  CASE_EXPECT_TRUE(etcd_mod1->get_conf_custom_data().empty());
-
-  etcd_mod1->set_conf_custom_data(custom_data_value);
-  CASE_EXPECT_EQ(custom_data_value, etcd_mod1->get_conf_custom_data());
-
   // Trigger the keepalive discovery value update flag
-  etcd_mod1->set_maybe_update_keepalive_discovery_value();
+  discovery1->set_maybe_update_keepalive_discovery_value();
 
   // Tick to process the update
   run_apps_noblock(apps, 10);
 
-  // Verify custom_data is still set after ticking
-  CASE_EXPECT_EQ(custom_data_value, etcd_mod1->get_conf_custom_data());
-
   // Verify the discovery value was refreshed (node2 should still see node1 - the update
   // triggers a keepalive value regeneration, though custom_data is not packed into it
   // since app::pack() currently has custom_data commented out)
-  auto node = etcd_mod2->get_global_discovery().get_node_by_id(app1.get_id());
+  auto node = discovery2->get_global_discovery().get_node_by_id(app1.get_id());
   CASE_EXPECT_TRUE(!!node);
 
-  // Verify custom_data can be updated and cleared
-  etcd_mod1->set_conf_custom_data("updated-data");
-  CASE_EXPECT_EQ("updated-data", etcd_mod1->get_conf_custom_data());
-
-  etcd_mod1->set_conf_custom_data("");
-  CASE_EXPECT_TRUE(etcd_mod1->get_conf_custom_data().empty());
-
   CASE_MSG_INFO() << "multi_node_custom_data: local set/get API verified" << '\n';
 }
diff --git a/test/case/atapp_etcd_module_unit_test.cpp b/test/case/atapp_etcd_module_unit_test.cpp
index 908bbd2..daf8756 100644
--- a/test/case/atapp_etcd_module_unit_test.cpp
+++ b/test/case/atapp_etcd_module_unit_test.cpp
@@ -3,10 +3,11 @@
 //
 // Tests cover:
 //   1. atapp_area comparison semantics (atapp_discovery_equal logic)
-//   2. topology_storage_t version update semantics (topology_update_version logic)
+//   2. atapp::service_discovery_module::topology_storage_t version update semantics (topology_update_version logic)
 //   3. etcd_module pack/unpack round-trip for topology_info_t and node_info_t
 
 #include <atframe/modules/etcd_module.h>
+#include <atframe/modules/service_discovery_module.h>
 
 #include <atframe/etcdcli/etcd_def.h>
 
@@ -53,7 +54,7 @@ static bool test_atapp_area_equal(const atapp::protocol::atapp_area &l, const at
 }
 
 // Replicates the topology_update_version logic to verify by-reference semantics
-static bool test_topology_update_version(atapp::etcd_module::topology_storage_t &storage,
+static bool test_topology_update_version(atapp::service_discovery_module::topology_storage_t &storage,
                                          const atapp::etcd_data_version &new_version, bool upgrade) {
   bool ret = false;
   if (upgrade) {
@@ -238,7 +239,7 @@ CASE_TEST(atapp_etcd_module_unit, area_symmetric) {
 
 // ---- I.12 version update: upgrade with higher create_revision ----
 CASE_TEST(atapp_etcd_module_unit, version_upgrade_create_revision) {
-  atapp::etcd_module::topology_storage_t storage;
+  atapp::service_discovery_module::topology_storage_t storage;
   storage.version.create_revision = 10;
   storage.version.modify_revision = 20;
   storage.version.version = 1;
@@ -257,7 +258,7 @@ CASE_TEST(atapp_etcd_module_unit, version_upgrade_create_revision) {
 
 // ---- I.13 version update: upgrade with higher modify_revision ----
 CASE_TEST(atapp_etcd_module_unit, version_upgrade_modify_revision) {
-  atapp::etcd_module::topology_storage_t storage;
+  atapp::service_discovery_module::topology_storage_t storage;
   storage.version.create_revision = 10;
   storage.version.modify_revision = 20;
   storage.version.version = 1;
@@ -277,7 +278,7 @@ CASE_TEST(atapp_etcd_module_unit, version_upgrade_modify_revision) {
 
 // ---- I.14 version update: upgrade with higher version only ----
 CASE_TEST(atapp_etcd_module_unit, version_upgrade_version_only) {
-  atapp::etcd_module::topology_storage_t storage;
+  atapp::service_discovery_module::topology_storage_t storage;
   storage.version.create_revision = 10;
   storage.version.modify_revision = 20;
   storage.version.version = 1;
@@ -295,7 +296,7 @@ CASE_TEST(atapp_etcd_module_unit, version_upgrade_version_only) {
 
 // ---- I.15 version update: upgrade with no changes (all equal) ----
 CASE_TEST(atapp_etcd_module_unit, version_upgrade_no_change) {
-  atapp::etcd_module::topology_storage_t storage;
+  atapp::service_discovery_module::topology_storage_t storage;
   storage.version.create_revision = 10;
   storage.version.modify_revision = 20;
   storage.version.version = 3;
@@ -315,7 +316,7 @@ CASE_TEST(atapp_etcd_module_unit, version_upgrade_no_change) {
 
 // ---- I.16 version update: upgrade with lower values (no update) ----
 CASE_TEST(atapp_etcd_module_unit, version_upgrade_lower_values) {
-  atapp::etcd_module::topology_storage_t storage;
+  atapp::service_discovery_module::topology_storage_t storage;
   storage.version.create_revision = 10;
   storage.version.modify_revision = 20;
   storage.version.version = 3;
@@ -336,7 +337,7 @@ CASE_TEST(atapp_etcd_module_unit, version_upgrade_lower_values) {
 
 // ---- I.17 version update: non-upgrade (overwrite) mode ----
 CASE_TEST(atapp_etcd_module_unit, version_overwrite_mode) {
-  atapp::etcd_module::topology_storage_t storage;
+  atapp::service_discovery_module::topology_storage_t storage;
   storage.version.create_revision = 100;
   storage.version.modify_revision = 200;
   storage.version.version = 50;
@@ -357,7 +358,7 @@ CASE_TEST(atapp_etcd_module_unit, version_overwrite_mode) {
 
 // ---- I.18 version update: upgrade with mixed higher/lower ----
 CASE_TEST(atapp_etcd_module_unit, version_upgrade_mixed) {
-  atapp::etcd_module::topology_storage_t storage;
+  atapp::service_discovery_module::topology_storage_t storage;
   storage.version.create_revision = 10;
   storage.version.modify_revision = 20;
   storage.version.version = 3;
@@ -382,9 +383,10 @@ CASE_TEST(atapp_etcd_module_unit, version_upgrade_mixed) {
 // This directly validates the fix: passing by value would NOT update the caller's storage
 CASE_TEST(atapp_etcd_module_unit, version_update_by_reference) {
   // Simulate the map lookup pattern from update_internal_watcher_event
-  std::unordered_map<uint64_t, atapp::etcd_module::topology_storage_t> topology_map;
+  std::unordered_map<uint64_t, atapp::service_discovery_module::topology_storage_t> topology_map;
 
-  atapp::etcd_module::topology_storage_t initial;
+  atapp::service_discovery_module::topology_storage_t initial;
+  initial.context_ptr = 0;
   initial.version.create_revision = 1;
   initial.version.modify_revision = 1;
   initial.version.version = 1;
@@ -411,7 +413,7 @@ CASE_TEST(atapp_etcd_module_unit, version_update_by_reference) {
 
 // ---- I.20 version update: multiple sequential upgrades ----
 CASE_TEST(atapp_etcd_module_unit, version_sequential_upgrades) {
-  atapp::etcd_module::topology_storage_t storage;
+  atapp::service_discovery_module::topology_storage_t storage;
   storage.version.create_revision = 0;
   storage.version.modify_revision = 0;
   storage.version.version = 0;
@@ -454,7 +456,7 @@ CASE_TEST(atapp_etcd_module_unit, version_sequential_upgrades) {
 
 // ---- I.21 version update: zero-initialized storage ----
 CASE_TEST(atapp_etcd_module_unit, version_upgrade_from_zero) {
-  atapp::etcd_module::topology_storage_t storage;
+  atapp::service_discovery_module::topology_storage_t storage;
   // Default construction leaves version at 0,0,0
 
   CASE_EXPECT_EQ(0, storage.version.create_revision);
@@ -634,13 +636,13 @@ CASE_TEST(atapp_etcd_module_unit, topology_equal_ignores_extra_fields) {
   CASE_EXPECT_TRUE(test_atapp_topology_equal(a, b));
 }
 
-// ==================== topology_storage_t map interaction tests ====================
+// ==================== atapp::service_discovery_module::topology_storage_t map interaction tests ====================
 // These tests verify the fix for topology_update_version being called
 // with storage from a map iterator, ensuring updates propagate.
 
 // ---- I.31 map-based version tracking: insert and upgrade ----
 CASE_TEST(atapp_etcd_module_unit, topology_map_insert_and_upgrade) {
-  std::unordered_map<uint64_t, atapp::etcd_module::topology_storage_t> topology_map;
+  std::unordered_map<uint64_t, atapp::service_discovery_module::topology_storage_t> topology_map;
 
   // Insert initial entry
   auto info = atfw::util::memory::make_strong_rc<atapp::protocol::atapp_topology_info>();
@@ -648,7 +650,8 @@ CASE_TEST(atapp_etcd_module_unit, topology_map_insert_and_upgrade) {
   info->set_name("server-100");
   info->set_upstream_id(1);
 
-  atapp::etcd_module::topology_storage_t entry;
+  atapp::service_discovery_module::topology_storage_t entry;
+  entry.context_ptr = 0;
   entry.info = info;
   entry.version.create_revision = 1;
   entry.version.modify_revision = 1;
@@ -677,12 +680,13 @@ CASE_TEST(atapp_etcd_module_unit, topology_map_insert_and_upgrade) {
 
 // ---- I.32 map-based version tracking: multiple entries independent ----
 CASE_TEST(atapp_etcd_module_unit, topology_map_multiple_entries) {
-  std::unordered_map<uint64_t, atapp::etcd_module::topology_storage_t> topology_map;
+  std::unordered_map<uint64_t, atapp::service_discovery_module::topology_storage_t> topology_map;
 
   for (uint64_t i = 1; i <= 3; ++i) {
-    atapp::etcd_module::topology_storage_t entry;
+    atapp::service_discovery_module::topology_storage_t entry;
     entry.info = atfw::util::memory::make_strong_rc<atapp::protocol::atapp_topology_info>();
     entry.info->set_id(i);
+    entry.context_ptr = 0;
     entry.version.create_revision = static_cast<int64_t>(i);
     entry.version.modify_revision = static_cast<int64_t>(i);
     entry.version.version = 1;
@@ -757,18 +761,15 @@ CASE_TEST(atapp_etcd_module_unit, generate_etcd_path_empty) {
 
 // ---- I.37 generate_etcd_path: append slash when separator missing ----
 CASE_TEST(atapp_etcd_module_unit, generate_etcd_path_append_slash) {
-  CASE_EXPECT_EQ(std::string("service/discovery/"),
-                 atapp::etcd_module::generate_etcd_path("service/discovery"));
+  CASE_EXPECT_EQ(std::string("service/discovery/"), atapp::etcd_module::generate_etcd_path("service/discovery"));
 }
 
 // ---- I.38 generate_etcd_path: preserve trailing slash ----
 CASE_TEST(atapp_etcd_module_unit, generate_etcd_path_preserve_slash) {
-  CASE_EXPECT_EQ(std::string("service/discovery/"),
-                 atapp::etcd_module::generate_etcd_path("service/discovery/"));
+  CASE_EXPECT_EQ(std::string("service/discovery/"), atapp::etcd_module::generate_etcd_path("service/discovery/"));
 }
 
 // ---- I.39 generate_etcd_path: preserve trailing backslash ----
 CASE_TEST(atapp_etcd_module_unit, generate_etcd_path_preserve_backslash) {
-  CASE_EXPECT_EQ(std::string("service\\discovery\\"),
-                 atapp::etcd_module::generate_etcd_path("service\\discovery\\"));
+  CASE_EXPECT_EQ(std::string("service\\discovery\\"), atapp::etcd_module::generate_etcd_path("service\\discovery\\"));
 }
diff --git a/test/case/atapp_message_test.cpp b/test/case/atapp_message_test.cpp
index e471fac..0c7f322 100644
--- a/test/case/atapp_message_test.cpp
+++ b/test/case/atapp_message_test.cpp
@@ -2,6 +2,7 @@
 
 #include <atframe/atapp.h>
 #include <atframe/modules/etcd_module.h>
+#include <atframe/modules/service_discovery_module.h>
 
 #include <common/file_system.h>
 
@@ -71,19 +72,19 @@ CASE_TEST(atapp_message, send_message_remote) {
   {
     atapp::protocol::atapp_discovery app2_discovery_info;
     app2.pack(app2_discovery_info);
-    app2_discovery->copy_from(app2_discovery_info, atapp::etcd_discovery_node::node_version());
+    app2_discovery->copy_from(app2_discovery_info, atapp::etcd_discovery_node::node_version(), 0);
   }
 
   {
     // Mutable app1 in app2 to get name of remote node
     atapp::protocol::atapp_discovery app1_discovery_info;
     app1.pack(app1_discovery_info);
-    app1_discovery->copy_from(app1_discovery_info, atapp::etcd_discovery_node::node_version());
+    app1_discovery->copy_from(app1_discovery_info, atapp::etcd_discovery_node::node_version(), 0);
   }
-  app1.get_etcd_module()->get_global_discovery().add_node(app1_discovery);
-  app2.get_etcd_module()->get_global_discovery().add_node(app1_discovery);
-  app1.get_etcd_module()->get_global_discovery().add_node(app2_discovery);
-  app2.get_etcd_module()->get_global_discovery().add_node(app2_discovery);
+  app1.get_service_discovery_module()->get_global_discovery().add_node(app1_discovery);
+  app2.get_service_discovery_module()->get_global_discovery().add_node(app1_discovery);
+  app1.get_service_discovery_module()->get_global_discovery().add_node(app2_discovery);
+  app2.get_service_discovery_module()->get_global_discovery().add_node(app2_discovery);
 
   CASE_EXPECT_TRUE(app1.mutable_endpoint(app2_discovery));
   CASE_EXPECT_TRUE(app2.mutable_endpoint(app1_discovery));
@@ -186,7 +187,7 @@ CASE_TEST(atapp_message, send_message_loopback) {
   auto self_discovery = atfw::util::memory::make_strong_rc<atapp::etcd_discovery_node>();
   atapp::protocol::atapp_discovery self_discovery_info;
   app1.pack(self_discovery_info);
-  self_discovery->copy_from(self_discovery_info, atapp::etcd_discovery_node::node_version());
+  self_discovery->copy_from(self_discovery_info, atapp::etcd_discovery_node::node_version(), 0);
   CASE_EXPECT_TRUE(app1.mutable_endpoint(self_discovery));
 
   now = atfw::util::time::time_utility::sys_now();
diff --git a/test/case/atapp_topology_change_test.cpp b/test/case/atapp_topology_change_test.cpp
index 4365ffe..5acfc62 100644
--- a/test/case/atapp_topology_change_test.cpp
+++ b/test/case/atapp_topology_change_test.cpp
@@ -8,6 +8,7 @@
 #include <atframe/atapp.h>
 #include <atframe/connectors/atapp_connector_atbus.h>
 #include <atframe/modules/etcd_module.h>
+#include <atframe/modules/service_discovery_module.h>
 #include <detail/libatbus_error.h>
 
 #include <common/file_system.h>
@@ -160,24 +161,24 @@ static void inject_3node_discovery(atframework::atapp::app &node1, atframework::
   {
     atapp::protocol::atapp_discovery info;
     node1.pack(info);
-    node1_disc->copy_from(info, atapp::etcd_discovery_node::node_version());
+    node1_disc->copy_from(info, atapp::etcd_discovery_node::node_version(), 0);
   }
   {
     atapp::protocol::atapp_discovery info;
     old_upstream.pack(info);
-    upstream_disc->copy_from(info, atapp::etcd_discovery_node::node_version());
+    upstream_disc->copy_from(info, atapp::etcd_discovery_node::node_version(), 0);
   }
   {
     atapp::protocol::atapp_discovery info;
     target.pack(info);
-    target_disc->copy_from(info, atapp::etcd_discovery_node::node_version());
+    target_disc->copy_from(info, atapp::etcd_discovery_node::node_version(), 0);
   }
 
   atframework::atapp::app *apps[] = {&node1, &old_upstream, &target};
   atfw::util::memory::strong_rc_ptr<atapp::etcd_discovery_node> discs[] = {node1_disc, upstream_disc, target_disc};
   for (auto *app : apps) {
     for (auto &disc : discs) {
-      app->get_etcd_module()->get_global_discovery().add_node(disc);
+      app->get_service_discovery_module()->get_global_discovery().add_node(disc);
     }
   }
 }
@@ -296,25 +297,25 @@ CASE_TEST(atapp_topology_change, topology_change_new_upstream_not_connected) {
   {
     atapp::protocol::atapp_discovery info;
     new_upstream.pack(info);
-    new_up_disc->copy_from(info, atapp::etcd_discovery_node::node_version());
+    new_up_disc->copy_from(info, atapp::etcd_discovery_node::node_version(), 0);
   }
   {
     atapp::protocol::atapp_discovery info;
     node1.pack(info);
-    node1_disc2->copy_from(info, atapp::etcd_discovery_node::node_version());
+    node1_disc2->copy_from(info, atapp::etcd_discovery_node::node_version(), 0);
   }
   {
     atapp::protocol::atapp_discovery info;
     target.pack(info);
-    target_disc2->copy_from(info, atapp::etcd_discovery_node::node_version());
+    target_disc2->copy_from(info, atapp::etcd_discovery_node::node_version(), 0);
   }
 
   // Inject discovery on all nodes
-  node1.get_etcd_module()->get_global_discovery().add_node(new_up_disc);
-  target.get_etcd_module()->get_global_discovery().add_node(new_up_disc);
-  new_upstream.get_etcd_module()->get_global_discovery().add_node(new_up_disc);
-  new_upstream.get_etcd_module()->get_global_discovery().add_node(node1_disc2);
-  new_upstream.get_etcd_module()->get_global_discovery().add_node(target_disc2);
+  node1.get_service_discovery_module()->get_global_discovery().add_node(new_up_disc);
+  target.get_service_discovery_module()->get_global_discovery().add_node(new_up_disc);
+  new_upstream.get_service_discovery_module()->get_global_discovery().add_node(new_up_disc);
+  new_upstream.get_service_discovery_module()->get_global_discovery().add_node(node1_disc2);
+  new_upstream.get_service_discovery_module()->get_global_discovery().add_node(target_disc2);
 
   // Update bus topology registries for new upstream
   auto bus1 = node1.get_bus_node();
@@ -507,24 +508,24 @@ CASE_TEST(atapp_topology_change, topology_change_new_upstream_already_connected)
   {
     atapp::protocol::atapp_discovery info;
     new_upstream.pack(info);
-    new_up_disc->copy_from(info, atapp::etcd_discovery_node::node_version());
+    new_up_disc->copy_from(info, atapp::etcd_discovery_node::node_version(), 0);
   }
   {
     atapp::protocol::atapp_discovery info;
     node1.pack(info);
-    node1_disc2->copy_from(info, atapp::etcd_discovery_node::node_version());
+    node1_disc2->copy_from(info, atapp::etcd_discovery_node::node_version(), 0);
   }
   {
     atapp::protocol::atapp_discovery info;
     target.pack(info);
-    target_disc2->copy_from(info, atapp::etcd_discovery_node::node_version());
+    target_disc2->copy_from(info, atapp::etcd_discovery_node::node_version(), 0);
   }
 
-  node1.get_etcd_module()->get_global_discovery().add_node(new_up_disc);
-  target.get_etcd_module()->get_global_discovery().add_node(new_up_disc);
-  new_upstream.get_etcd_module()->get_global_discovery().add_node(new_up_disc);
-  new_upstream.get_etcd_module()->get_global_discovery().add_node(node1_disc2);
-  new_upstream.get_etcd_module()->get_global_discovery().add_node(target_disc2);
+  node1.get_service_discovery_module()->get_global_discovery().add_node(new_up_disc);
+  target.get_service_discovery_module()->get_global_discovery().add_node(new_up_disc);
+  new_upstream.get_service_discovery_module()->get_global_discovery().add_node(new_up_disc);
+  new_upstream.get_service_discovery_module()->get_global_discovery().add_node(node1_disc2);
+  new_upstream.get_service_discovery_module()->get_global_discovery().add_node(target_disc2);
 
   // Update bus topology registries
   auto bus1 = node1.get_bus_node();
@@ -744,25 +745,25 @@ CASE_TEST(atapp_topology_change, topology_change_discovery_missing_then_arrive)
   {
     atapp::protocol::atapp_discovery info;
     new_upstream.pack(info);
-    new_up_disc->copy_from(info, atapp::etcd_discovery_node::node_version());
+    new_up_disc->copy_from(info, atapp::etcd_discovery_node::node_version(), 0);
   }
   {
     atapp::protocol::atapp_discovery info;
     node1.pack(info);
-    node1_disc2->copy_from(info, atapp::etcd_discovery_node::node_version());
+    node1_disc2->copy_from(info, atapp::etcd_discovery_node::node_version(), 0);
   }
   {
     atapp::protocol::atapp_discovery info;
     target.pack(info);
-    target_disc2->copy_from(info, atapp::etcd_discovery_node::node_version());
+    target_disc2->copy_from(info, atapp::etcd_discovery_node::node_version(), 0);
   }
 
   // Inject discovery for new_upstream on all nodes
-  node1.get_etcd_module()->get_global_discovery().add_node(new_up_disc);
-  target.get_etcd_module()->get_global_discovery().add_node(new_up_disc);
-  new_upstream.get_etcd_module()->get_global_discovery().add_node(new_up_disc);
-  new_upstream.get_etcd_module()->get_global_discovery().add_node(node1_disc2);
-  new_upstream.get_etcd_module()->get_global_discovery().add_node(target_disc2);
+  node1.get_service_discovery_module()->get_global_discovery().add_node(new_up_disc);
+  target.get_service_discovery_module()->get_global_discovery().add_node(new_up_disc);
+  new_upstream.get_service_discovery_module()->get_global_discovery().add_node(new_up_disc);
+  new_upstream.get_service_discovery_module()->get_global_discovery().add_node(node1_disc2);
+  new_upstream.get_service_discovery_module()->get_global_discovery().add_node(target_disc2);
 
   // Create endpoints for new_upstream
   CASE_EXPECT_TRUE(node1.mutable_endpoint(new_up_disc));
diff --git a/test/case/atapp_upstream_forward_test.cpp b/test/case/atapp_upstream_forward_test.cpp
index 8f8846f..843e925 100644
--- a/test/case/atapp_upstream_forward_test.cpp
+++ b/test/case/atapp_upstream_forward_test.cpp
@@ -7,6 +7,7 @@
 #include <atframe/atapp.h>
 #include <atframe/connectors/atapp_connector_atbus.h>
 #include <atframe/modules/etcd_module.h>
+#include <atframe/modules/service_discovery_module.h>
 #include <detail/libatbus_error.h>
 
 #include <common/file_system.h>
@@ -130,23 +131,23 @@ struct three_node_apps {
     {
       atapp::protocol::atapp_discovery info;
       node1.pack(info);
-      node1_discovery->copy_from(info, atapp::etcd_discovery_node::node_version());
+      node1_discovery->copy_from(info, atapp::etcd_discovery_node::node_version(), 0);
     }
     {
       atapp::protocol::atapp_discovery info;
       upstream.pack(info);
-      upstream_discovery->copy_from(info, atapp::etcd_discovery_node::node_version());
+      upstream_discovery->copy_from(info, atapp::etcd_discovery_node::node_version(), 0);
     }
     {
       atapp::protocol::atapp_discovery info;
       node3.pack(info);
-      node3_discovery->copy_from(info, atapp::etcd_discovery_node::node_version());
+      node3_discovery->copy_from(info, atapp::etcd_discovery_node::node_version(), 0);
     }
 
     // All nodes know about all other nodes
-    auto &node1_gd = node1.get_etcd_module()->get_global_discovery();
-    auto &upstream_gd = upstream.get_etcd_module()->get_global_discovery();
-    auto &node3_gd = node3.get_etcd_module()->get_global_discovery();
+    auto &node1_gd = node1.get_service_discovery_module()->get_global_discovery();
+    auto &upstream_gd = upstream.get_service_discovery_module()->get_global_discovery();
+    auto &node3_gd = node3.get_service_discovery_module()->get_global_discovery();
 
     node1_gd.add_node(node1_discovery);
     node1_gd.add_node(upstream_discovery);
@@ -168,17 +169,17 @@ struct three_node_apps {
     {
       atapp::protocol::atapp_discovery info;
       node1.pack(info);
-      node1_discovery->copy_from(info, atapp::etcd_discovery_node::node_version());
+      node1_discovery->copy_from(info, atapp::etcd_discovery_node::node_version(), 0);
     }
     {
       atapp::protocol::atapp_discovery info;
       upstream.pack(info);
-      upstream_discovery->copy_from(info, atapp::etcd_discovery_node::node_version());
+      upstream_discovery->copy_from(info, atapp::etcd_discovery_node::node_version(), 0);
     }
 
-    auto &node1_gd = node1.get_etcd_module()->get_global_discovery();
-    auto &upstream_gd = upstream.get_etcd_module()->get_global_discovery();
-    auto &node3_gd = node3.get_etcd_module()->get_global_discovery();
+    auto &node1_gd = node1.get_service_discovery_module()->get_global_discovery();
+    auto &upstream_gd = upstream.get_service_discovery_module()->get_global_discovery();
+    auto &node3_gd = node3.get_service_discovery_module()->get_global_discovery();
 
     node1_gd.add_node(node1_discovery);
     node1_gd.add_node(upstream_discovery);
@@ -194,12 +195,12 @@ struct three_node_apps {
     {
       atapp::protocol::atapp_discovery info;
       node3.pack(info);
-      node3_discovery->copy_from(info, atapp::etcd_discovery_node::node_version());
+      node3_discovery->copy_from(info, atapp::etcd_discovery_node::node_version(), 0);
     }
 
-    auto &node1_gd = node1.get_etcd_module()->get_global_discovery();
-    auto &upstream_gd = upstream.get_etcd_module()->get_global_discovery();
-    auto &node3_gd = node3.get_etcd_module()->get_global_discovery();
+    auto &node1_gd = node1.get_service_discovery_module()->get_global_discovery();
+    auto &upstream_gd = upstream.get_service_discovery_module()->get_global_discovery();
+    auto &node3_gd = node3.get_service_discovery_module()->get_global_discovery();
 
     node1_gd.add_node(node3_discovery);
     upstream_gd.add_node(node3_discovery);
@@ -507,8 +508,8 @@ CASE_TEST(atapp_upstream_forward, upstream_connected_target_unreachable) {
   atapp::protocol::atapp_discovery fake_info;
   fake_info.set_id(nonexistent_id);
   fake_info.set_name("nonexistent-node");
-  fake_discovery->copy_from(fake_info, atapp::etcd_discovery_node::node_version());
-  apps.node1.get_etcd_module()->get_global_discovery().add_node(fake_discovery);
+  fake_discovery->copy_from(fake_info, atapp::etcd_discovery_node::node_version(), 0);
+  apps.node1.get_service_discovery_module()->get_global_discovery().add_node(fake_discovery);
   apps.node1.mutable_endpoint(fake_discovery);
 
   // Setup forward response to capture error
@@ -1219,24 +1220,24 @@ CASE_TEST(atapp_upstream_forward, upstream_topology_change_new_upstream) {
     {
       atapp::protocol::atapp_discovery info;
       node1.pack(info);
-      node1_disc->copy_from(info, atapp::etcd_discovery_node::node_version());
+      node1_disc->copy_from(info, atapp::etcd_discovery_node::node_version(), 0);
     }
     {
       atapp::protocol::atapp_discovery info;
       upstream_app.pack(info);
-      upstream_disc->copy_from(info, atapp::etcd_discovery_node::node_version());
+      upstream_disc->copy_from(info, atapp::etcd_discovery_node::node_version(), 0);
     }
     {
       atapp::protocol::atapp_discovery info;
       node3.pack(info);
-      node3_disc->copy_from(info, atapp::etcd_discovery_node::node_version());
+      node3_disc->copy_from(info, atapp::etcd_discovery_node::node_version(), 0);
     }
 
     atframework::atapp::app *apps[] = {&node1, &upstream_app, &node3};
     atfw::util::memory::strong_rc_ptr<atapp::etcd_discovery_node> discs[] = {node1_disc, upstream_disc, node3_disc};
     for (auto *app : apps) {
       for (auto &disc : discs) {
-        app->get_etcd_module()->get_global_discovery().add_node(disc);
+        app->get_service_discovery_module()->get_global_discovery().add_node(disc);
       }
     }
 
@@ -1365,24 +1366,24 @@ CASE_TEST(atapp_upstream_forward, upstream_topology_change_new_upstream) {
   {
     atapp::protocol::atapp_discovery info;
     new_upstream.pack(info);
-    new_up_disc->copy_from(info, atapp::etcd_discovery_node::node_version());
+    new_up_disc->copy_from(info, atapp::etcd_discovery_node::node_version(), 0);
   }
   {
     atapp::protocol::atapp_discovery info;
     node1.pack(info);
-    node1_disc2->copy_from(info, atapp::etcd_discovery_node::node_version());
+    node1_disc2->copy_from(info, atapp::etcd_discovery_node::node_version(), 0);
   }
   {
     atapp::protocol::atapp_discovery info;
     node3.pack(info);
-    node3_disc2->copy_from(info, atapp::etcd_discovery_node::node_version());
+    node3_disc2->copy_from(info, atapp::etcd_discovery_node::node_version(), 0);
   }
 
-  node1.get_etcd_module()->get_global_discovery().add_node(new_up_disc);
-  node3.get_etcd_module()->get_global_discovery().add_node(new_up_disc);
-  new_upstream.get_etcd_module()->get_global_discovery().add_node(new_up_disc);
-  new_upstream.get_etcd_module()->get_global_discovery().add_node(node1_disc2);
-  new_upstream.get_etcd_module()->get_global_discovery().add_node(node3_disc2);
+  node1.get_service_discovery_module()->get_global_discovery().add_node(new_up_disc);
+  node3.get_service_discovery_module()->get_global_discovery().add_node(new_up_disc);
+  new_upstream.get_service_discovery_module()->get_global_discovery().add_node(new_up_disc);
+  new_upstream.get_service_discovery_module()->get_global_discovery().add_node(node1_disc2);
+  new_upstream.get_service_discovery_module()->get_global_discovery().add_node(node3_disc2);
 
   // Update bus topology registries for the new upstream
   auto bus1 = node1.get_bus_node();

From 8cea8e99ed8f42ed184548b311d690a961c5796a Mon Sep 17 00:00:00 2001
From: yousongyang <yousongyang0105@gmail.com>
Date: Wed, 10 Jun 2026 14:39:31 +0800
Subject: [PATCH 02/12] =?UTF-8?q?ETCD=20=E4=B8=8E=20Discovery=20=E5=88=86?=
 =?UTF-8?q?=E7=A6=BB=20CR?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 include/atframe/atapp.h                       |   2 +-
 include/atframe/etcdcli/etcd_discovery.h      |   8 +-
 .../modules/service_discovery_module.h        |  81 ++--
 src/atframe/atapp.cpp                         |   9 +-
 src/atframe/etcdcli/etcd_discovery.cpp        |   9 +-
 src/atframe/modules/etcd_module.cpp           |   5 +-
 .../modules/service_discovery_module.cpp      | 437 +++++++++++-------
 test/case/atapp_discovery_test.cpp            |   4 +-
 test/case/atapp_etcd_module_test.cpp          | 260 ++++++++++-
 test/case/atapp_etcd_module_unit_test.cpp     |   6 +-
 ..._test_etcd_module_multi_context_node2.yaml |  78 ++++
 11 files changed, 662 insertions(+), 237 deletions(-)
 create mode 100644 test/case/atapp_test_etcd_module_multi_context_node2.yaml

diff --git a/include/atframe/atapp.h b/include/atframe/atapp.h
index e128876..2cc816e 100644
--- a/include/atframe/atapp.h
+++ b/include/atframe/atapp.h
@@ -54,7 +54,7 @@ class service_discovery_module;
 class worker_pool_module;
 class atapp_connector_atbus;
 class atapp_connector_loopback;
-struct curl_multi_guard_type;
+struct LIBATAPP_MACRO_API curl_multi_guard_type;
 
 class app {
  public:
diff --git a/include/atframe/etcdcli/etcd_discovery.h b/include/atframe/etcdcli/etcd_discovery.h
index f98f8e7..355b00a 100644
--- a/include/atframe/etcdcli/etcd_discovery.h
+++ b/include/atframe/etcdcli/etcd_discovery.h
@@ -50,11 +50,11 @@ class etcd_discovery_node {
   ATFW_UTIL_FORCEINLINE const node_version &get_version() const noexcept { return node_version_; }
 
   LIBATAPP_MACRO_API void copy_from(const atapp::protocol::atapp_discovery &input, const node_version &version,
-                                    uintptr_t context_ptr);
-  LIBATAPP_MACRO_API void update_version(const node_version &version, bool upgrade, uintptr_t context_ptr);
+                                    uintptr_t context_addr);
+  LIBATAPP_MACRO_API void update_version(const node_version &version, bool upgrade);
   LIBATAPP_MACRO_API void copy_to(atapp::protocol::atapp_discovery &output) const;
   LIBATAPP_MACRO_API void copy_key_to(atapp::protocol::atapp_discovery &output) const;
-  LIBATAPP_MACRO_API uintptr_t get_context_ptr() const noexcept { return context_ptr_; }
+  LIBATAPP_MACRO_API uintptr_t get_context_addr() const noexcept { return context_addr_; }
 
   ATFW_UTIL_FORCEINLINE const std::pair<uint64_t, uint64_t> &get_name_hash() const noexcept { return name_hash_; }
 
@@ -80,7 +80,7 @@ class etcd_discovery_node {
  private:
   atapp::protocol::atapp_discovery node_info_;
   node_version node_version_;
-  uintptr_t context_ptr_;
+  uintptr_t context_addr_;
 
   std::pair<uint64_t, uint64_t> name_hash_;
   union {
diff --git a/include/atframe/modules/service_discovery_module.h b/include/atframe/modules/service_discovery_module.h
index 8c09a5a..36fcf08 100644
--- a/include/atframe/modules/service_discovery_module.h
+++ b/include/atframe/modules/service_discovery_module.h
@@ -30,7 +30,7 @@ class service_discovery_module : public ::atframework::atapp::module_impl {
 
   struct LIBATAPP_MACRO_API_HEAD_ONLY node_info_t {
     atapp::protocol::atapp_discovery node_discovery;
-    uintptr_t context_ptr = 0;
+    uintptr_t context_addr = 0;
     node_action_t action;
   };
 
@@ -72,7 +72,7 @@ class service_discovery_module : public ::atframework::atapp::module_impl {
 
   struct LIBATAPP_MACRO_API_HEAD_ONLY topology_storage_t {
     atapp_topology_info_ptr_t info;
-    uintptr_t context_ptr = 0;
+    uintptr_t context_addr = 0;
     etcd_data_version version;
   };
 
@@ -128,6 +128,7 @@ class service_discovery_module : public ::atframework::atapp::module_impl {
                                   const atapp::protocol::atapp_log *ATFW_UTIL_MACRO_NULLABLE log_conf);
     LIBATAPP_MACRO_API int stop();
     LIBATAPP_MACRO_API void tick();
+    LIBATAPP_MACRO_API void reset();
 
    public:
     LIBATAPP_MACRO_API etcd_module &get_etcd_module();
@@ -158,6 +159,7 @@ class service_discovery_module : public ::atframework::atapp::module_impl {
   LIBATAPP_MACRO_API int stop() override;
   LIBATAPP_MACRO_API int reload() override;
   LIBATAPP_MACRO_API int tick() override;
+  LIBATAPP_MACRO_API int timeout() override;
 
  public:
   LIBATAPP_MACRO_API bool is_discovery_enabled() const;
@@ -181,26 +183,40 @@ class service_discovery_module : public ::atframework::atapp::module_impl {
   LIBATAPP_MACRO_API static std::string get_topology_watcher_path(atframework::atapp::app &app,
                                                                   const std::string &path);
 
-  LIBATAPP_MACRO_API int init_service_discovery_keepalives_watchers(service_discovery_cluster_context &context);
-
-  LIBATAPP_MACRO_API static int init_discovery_watcher_by_id(atframework::atapp::app &app,
-                                                             service_discovery_cluster_context &context);
-  LIBATAPP_MACRO_API static int init_discovery_watcher_by_name(atframework::atapp::app &app,
-                                                               service_discovery_cluster_context &context);
-  LIBATAPP_MACRO_API static int init_topology_watcher(atframework::atapp::app &app,
-                                                      service_discovery_cluster_context &context);
-  LIBATAPP_MACRO_API static int init_discovery_keepalive_by_id(atframework::atapp::app &app,
-                                                               service_discovery_cluster_context &context,
-                                                               std::string &value);
-  LIBATAPP_MACRO_API static int init_discovery_keepalive_by_name(atframework::atapp::app &app,
-                                                                 service_discovery_cluster_context &context,
-                                                                 std::string &value);
-  LIBATAPP_MACRO_API static int init_topology_keepalive(atframework::atapp::app &app,
-                                                        service_discovery_cluster_context &context, std::string &value);
-
-  LIBATAPP_MACRO_API int add_discovery_watcher_by_id_callback(const discovery_watcher_list_callback_t &fn);
-  LIBATAPP_MACRO_API int add_discovery_watcher_by_name_callback(const discovery_watcher_list_callback_t &fn);
-  LIBATAPP_MACRO_API int add_topology_watcher_callback(const topology_watcher_list_callback_t &fn);
+  LIBATAPP_MACRO_API int init_service_discovery_keepalives_watchers(
+      ::atfw::util::nostd::nonnull<std::shared_ptr<service_discovery_cluster_context>> context);
+
+  LIBATAPP_MACRO_API static int init_discovery_watcher_by_id(
+      atframework::atapp::app &app,
+      ::atfw::util::nostd::nonnull<std::shared_ptr<service_discovery_cluster_context>> context);
+  LIBATAPP_MACRO_API static int init_discovery_watcher_by_name(
+      atframework::atapp::app &app,
+      ::atfw::util::nostd::nonnull<std::shared_ptr<service_discovery_cluster_context>> context);
+  LIBATAPP_MACRO_API static int init_topology_watcher(
+      atframework::atapp::app &app,
+      ::atfw::util::nostd::nonnull<std::shared_ptr<service_discovery_cluster_context>> context);
+  LIBATAPP_MACRO_API static int init_discovery_keepalive_by_id(
+      atframework::atapp::app &app,
+      ::atfw::util::nostd::nonnull<std::shared_ptr<service_discovery_cluster_context>> context, std::string &value);
+  LIBATAPP_MACRO_API static int init_discovery_keepalive_by_name(
+      atframework::atapp::app &app,
+      ::atfw::util::nostd::nonnull<std::shared_ptr<service_discovery_cluster_context>> context, std::string &value);
+  LIBATAPP_MACRO_API static int init_topology_keepalive(
+      atframework::atapp::app &app,
+      ::atfw::util::nostd::nonnull<std::shared_ptr<service_discovery_cluster_context>> context, std::string &value);
+
+  LIBATAPP_MACRO_API static int add_discovery_watcher_by_id_callback(
+      atframework::atapp::app &app,
+      ::atfw::util::nostd::nonnull<std::shared_ptr<service_discovery_cluster_context>> context,
+      const discovery_watcher_list_callback_t &fn);
+  LIBATAPP_MACRO_API static int add_discovery_watcher_by_name_callback(
+      atframework::atapp::app &app,
+      ::atfw::util::nostd::nonnull<std::shared_ptr<service_discovery_cluster_context>> context,
+      const discovery_watcher_list_callback_t &fn);
+  LIBATAPP_MACRO_API static int add_topology_watcher_callback(
+      atframework::atapp::app &app,
+      ::atfw::util::nostd::nonnull<std::shared_ptr<service_discovery_cluster_context>> context,
+      const topology_watcher_list_callback_t &fn);
 
   LIBATAPP_MACRO_API const ::atframework::atapp::etcd_cluster &get_raw_etcd_ctx() const;
   LIBATAPP_MACRO_API ::atframework::atapp::etcd_cluster &get_raw_etcd_ctx();
@@ -213,16 +229,17 @@ class service_discovery_module : public ::atframework::atapp::module_impl {
   LIBATAPP_MACRO_API const atapp::protocol::atapp_etcd &get_configure() const;
   LIBATAPP_MACRO_API const std::string &get_configure_path();
 
-  LIBATAPP_MACRO_API static atapp::etcd_keepalive::ptr_t add_keepalive_actor(atframework::atapp::app &app,
-                                                                             service_discovery_cluster_context &context,
-                                                                             std::string &val,
-                                                                             const std::string &node_path);
+  LIBATAPP_MACRO_API static atapp::etcd_keepalive::ptr_t add_keepalive_actor(
+      atframework::atapp::app &app,
+      ::atfw::util::nostd::nonnull<std::shared_ptr<service_discovery_cluster_context>> context, std::string &val,
+      const std::string &node_path);
   LIBATAPP_MACRO_API atapp::etcd_keepalive::ptr_t add_keepalive_actor(atframework::atapp::app &app, std::string &val,
                                                                       const std::string &node_path);
 
-  LIBATAPP_MACRO_API static bool remove_keepalive_actor(atframework::atapp::app &app,
-                                                        service_discovery_cluster_context &context,
-                                                        const atapp::etcd_keepalive::ptr_t &keepalive);
+  LIBATAPP_MACRO_API static bool remove_keepalive_actor(
+      atframework::atapp::app &app,
+      ::atfw::util::nostd::nonnull<std::shared_ptr<service_discovery_cluster_context>> context,
+      const atapp::etcd_keepalive::ptr_t &keepalive);
   LIBATAPP_MACRO_API bool remove_keepalive_actor(atframework::atapp::app &app,
                                                  const atapp::etcd_keepalive::ptr_t &keepalive);
 
@@ -257,9 +274,9 @@ class service_discovery_module : public ::atframework::atapp::module_impl {
   LIBATAPP_MACRO_API void remove_on_topology_snapshot_loaded(topology_snapshot_event_callback_handle_t &handle);
 
   LIBATAPP_MACRO_API etcd_watcher::watch_event_fn_t_ptr create_discovery_watcher_callback_list_wrapper(
-      service_discovery_cluster_context &context);
+      ::atfw::util::nostd::nonnull<std::shared_ptr<service_discovery_cluster_context>> context);
   LIBATAPP_MACRO_API etcd_watcher::watch_event_fn_t_ptr create_topology_watcher_callback_list_wrapper(
-      service_discovery_cluster_context &context);
+      ::atfw::util::nostd::nonnull<std::shared_ptr<service_discovery_cluster_context>> context);
 
  private:
   static bool unpack(node_info_t &out, const std::string &path, const std::string &json, bool reset_data);
@@ -277,7 +294,7 @@ class service_discovery_module : public ::atframework::atapp::module_impl {
 
  private:
   bool discovery_enabled_;
-  service_discovery_cluster_context cluster_context_;
+  ::atfw::util::nostd::nonnull<std::shared_ptr<service_discovery_cluster_context>> cluster_context_;
 
   bool maybe_update_internal_keepalive_topology_value_;
   bool maybe_update_internal_keepalive_discovery_value_;
diff --git a/src/atframe/atapp.cpp b/src/atframe/atapp.cpp
index dbe2be8..1d63a45 100644
--- a/src/atframe/atapp.cpp
+++ b/src/atframe/atapp.cpp
@@ -325,22 +325,25 @@ static std::chrono::system_clock::duration &atapp_get_sys_now_offset() {
 
 }  // namespace
 
-struct ATFW_UTIL_SYMBOL_LOCAL curl_multi_guard_type {
+struct LIBATAPP_MACRO_API curl_multi_guard_type {
   curl_multi_guard_type() { init_result = curl_global_init(CURL_GLOBAL_ALL); }
   ~curl_multi_guard_type() {
-    if (init_result == 0) {
+    if (init_result == CURLE_OK) {
       curl_global_cleanup();
     }
   }
   int init_result;
 };
+
+namespace {
 static std::shared_ptr<curl_multi_guard_type> create_curl_multi_guard() {
   std::shared_ptr<curl_multi_guard_type> guard = std::make_shared<curl_multi_guard_type>();
-  if (guard->init_result != 0) {
+  if (guard->init_result != CURLE_OK) {
     return nullptr;
   }
   return guard;
 }
+}
 
 LIBATAPP_MACRO_API app::message_t::message_t() : type(0), message_sequence(0), metadata(nullptr) {}
 LIBATAPP_MACRO_API app::message_t::~message_t() {}
diff --git a/src/atframe/etcdcli/etcd_discovery.cpp b/src/atframe/etcdcli/etcd_discovery.cpp
index 0d38059..d2db2b6 100644
--- a/src/atframe/etcdcli/etcd_discovery.cpp
+++ b/src/atframe/etcdcli/etcd_discovery.cpp
@@ -256,7 +256,7 @@ static bool node_equal(const etcd_discovery_node::ptr_t &l, const etcd_discovery
 
 }  // namespace
 
-LIBATAPP_MACRO_API etcd_discovery_node::etcd_discovery_node() : context_ptr_(0), name_hash_(0, 0), ingress_index_(0) {
+LIBATAPP_MACRO_API etcd_discovery_node::etcd_discovery_node() : context_addr_(0), name_hash_(0, 0), ingress_index_(0) {
   private_data_ptr_ = nullptr;
   private_data_u64_ = 0;
   private_data_uptr_ = 0;
@@ -269,19 +269,19 @@ LIBATAPP_MACRO_API etcd_discovery_node::~etcd_discovery_node() {
 }
 
 LIBATAPP_MACRO_API void etcd_discovery_node::copy_from(const atapp::protocol::atapp_discovery &input,
-                                                       const node_version &version, uintptr_t context_ptr) {
+                                                       const node_version &version, uintptr_t context_addr) {
   node_info_.CopyFrom(input);
 
   name_hash_ = consistent_hash_calc(
       gsl::span<const unsigned char>{reinterpret_cast<const unsigned char *>(input.name().data()), input.name().size()},
       LIBATAPP_MACRO_HASH_MAGIC_NUMBER);
 
-  context_ptr_ = context_ptr;
+  context_addr_ = context_addr;
 
   node_version_ = version;
 }
 
-LIBATAPP_MACRO_API void etcd_discovery_node::update_version(const node_version &version, bool upgrade, uintptr_t context_ptr) {
+LIBATAPP_MACRO_API void etcd_discovery_node::update_version(const node_version &version, bool upgrade) {
   if (upgrade) {
     if (version.create_revision > node_version_.create_revision) {
       node_version_.create_revision = version.create_revision;
@@ -299,7 +299,6 @@ LIBATAPP_MACRO_API void etcd_discovery_node::update_version(const node_version &
   } else {
     node_version_ = version;
   }
-  context_ptr_ = context_ptr;
 }
 
 LIBATAPP_MACRO_API void etcd_discovery_node::copy_to(atapp::protocol::atapp_discovery &output) const {
diff --git a/src/atframe/modules/etcd_module.cpp b/src/atframe/modules/etcd_module.cpp
index 8c6b876..eedbdc9 100644
--- a/src/atframe/modules/etcd_module.cpp
+++ b/src/atframe/modules/etcd_module.cpp
@@ -506,8 +506,11 @@ int etcd_module::http_callback_on_etcd_closed(atfw::util::network::http_request
   }
 
   self->reset();
-
   LIBATAPP_MACRO_ETCD_CLUSTER_LOG_DEBUG(self->cluster_, "Etcd revoke lease finished");
+
+  if (self->atapp_ != nullptr) {
+    self->atapp_->stop();
+  }
   return 0;
 }
 
diff --git a/src/atframe/modules/service_discovery_module.cpp b/src/atframe/modules/service_discovery_module.cpp
index bcc0d23..9808e94 100644
--- a/src/atframe/modules/service_discovery_module.cpp
+++ b/src/atframe/modules/service_discovery_module.cpp
@@ -26,11 +26,11 @@
 
 #include <algorithm>
 #include <memory>
+#include <set>
 #include <string>
 #include <unordered_map>
 #include <utility>
 #include <vector>
-#include <set>
 
 #if defined(max)
 #  undef max
@@ -97,7 +97,7 @@ static bool atapp_topology_equal(const atapp::protocol::atapp_topology_info &l,
 }
 
 static bool topology_update_version(service_discovery_module::topology_storage_t &storage,
-                                    const etcd_data_version &new_version, bool upgrade, uintptr_t context_ptr) {
+                                    const etcd_data_version &new_version, bool upgrade) {
   bool ret = false;
   if (upgrade) {
     if (new_version.create_revision > storage.version.create_revision) {
@@ -120,57 +120,56 @@ static bool topology_update_version(service_discovery_module::topology_storage_t
     storage.version = new_version;
     ret = true;
   }
-  if (ret) {
-    storage.context_ptr = context_ptr;
-  }
 
   return ret;
 }
 }  // namespace
 
 struct ATFW_UTIL_SYMBOL_LOCAL service_discovery_module::topology_watcher_callback_list_wrapper_t {
-  service_discovery_module *mod;
-  service_discovery_cluster_context *ctx;
+  service_discovery_module *ATFW_UTIL_MACRO_NONNULL mod;
+  ::atfw::util::nostd::nonnull<std::shared_ptr<service_discovery_cluster_context>> ctx;
 
-  std::recursive_mutex *callback_lock;
-  std::list<topology_watcher_list_callback_t> *callbacks;
+  std::recursive_mutex *ATFW_UTIL_MACRO_NULLABLE callback_lock;
+  std::list<topology_watcher_list_callback_t> *ATFW_UTIL_MACRO_NULLABLE callbacks;
   int64_t snapshot_index;
   bool has_insert_snapshot_index;
 
-  topology_watcher_callback_list_wrapper_t(service_discovery_module &m, service_discovery_cluster_context &c,
-                                           int64_t index);
-  topology_watcher_callback_list_wrapper_t(service_discovery_module &m, service_discovery_cluster_context &c,
-                                           std::recursive_mutex &lock,
-                                           std::list<topology_watcher_list_callback_t> &cbks, int64_t index);
+  topology_watcher_callback_list_wrapper_t(
+      service_discovery_module &m, ::atfw::util::nostd::nonnull<std::shared_ptr<service_discovery_cluster_context>> c,
+      int64_t index);
+  topology_watcher_callback_list_wrapper_t(
+      service_discovery_module &m, ::atfw::util::nostd::nonnull<std::shared_ptr<service_discovery_cluster_context>> c,
+      std::recursive_mutex &lock, std::list<topology_watcher_list_callback_t> &cbks, int64_t index);
   ~topology_watcher_callback_list_wrapper_t();
   void operator()(const ::atframework::atapp::etcd_response_header &header,
                   const ::atframework::atapp::etcd_watcher::response_t &body);
 };
 
 struct ATFW_UTIL_SYMBOL_LOCAL service_discovery_module::discovery_watcher_callback_list_wrapper_t {
-  service_discovery_module *mod;
-  service_discovery_cluster_context *ctx;
+  service_discovery_module *ATFW_UTIL_MACRO_NONNULL mod;
+  ::atfw::util::nostd::nonnull<std::shared_ptr<service_discovery_cluster_context>> ctx;
 
-  std::recursive_mutex *callback_lock;
-  std::list<discovery_watcher_list_callback_t> *callbacks;
+  std::recursive_mutex *ATFW_UTIL_MACRO_NULLABLE callback_lock;
+  std::list<discovery_watcher_list_callback_t> *ATFW_UTIL_MACRO_NULLABLE callbacks;
   int64_t snapshot_index;
   bool has_insert_snapshot_index;
 
-  discovery_watcher_callback_list_wrapper_t(service_discovery_module &m, service_discovery_cluster_context &c,
-                                            int64_t index);
-  discovery_watcher_callback_list_wrapper_t(service_discovery_module &m, service_discovery_cluster_context &c,
-                                            std::recursive_mutex &lock,
-                                            std::list<discovery_watcher_list_callback_t> &cbks, int64_t index);
+  discovery_watcher_callback_list_wrapper_t(
+      service_discovery_module &m, ::atfw::util::nostd::nonnull<std::shared_ptr<service_discovery_cluster_context>> c,
+      int64_t index);
+  discovery_watcher_callback_list_wrapper_t(
+      service_discovery_module &m, ::atfw::util::nostd::nonnull<std::shared_ptr<service_discovery_cluster_context>> c,
+      std::recursive_mutex &lock, std::list<discovery_watcher_list_callback_t> &cbks, int64_t index);
   ~discovery_watcher_callback_list_wrapper_t();
   void operator()(const ::atframework::atapp::etcd_response_header &header,
                   const ::atframework::atapp::etcd_watcher::response_t &body);
 };
 
 struct ATFW_UTIL_SYMBOL_LOCAL service_discovery_module::watcher_internal_access_t {
-  static void cleanup_old_nodes(service_discovery_module &mod, service_discovery_cluster_context &c,
+  static void cleanup_old_nodes(service_discovery_module &mod, service_discovery_cluster_context &ctx,
                                 etcd_discovery_set::node_by_name_type &old_names,
                                 etcd_discovery_set::node_by_id_type &old_ids);
-  static void cleanup_old_topology_peers(service_discovery_module &mod, service_discovery_cluster_context &c,
+  static void cleanup_old_topology_peers(service_discovery_module &mod, service_discovery_cluster_context &ctx,
                                          std::unordered_map<uint64_t, topology_storage_t> &old_ids);
 };
 
@@ -216,13 +215,14 @@ struct ATFW_UTIL_SYMBOL_LOCAL service_discovery_module::service_discovery_cluste
 LIBATAPP_MACRO_API
 service_discovery_module::service_discovery_module()
     : discovery_enabled_(true),
+      cluster_context_(std::make_shared<service_discovery_cluster_context>()),
       maybe_update_internal_keepalive_topology_value_(true),
       maybe_update_internal_keepalive_discovery_value_(true),
       maybe_update_internal_keepalive_discovery_area_(false),
       maybe_update_internal_keepalive_discovery_metadata_(false) {}
 
 LIBATAPP_MACRO_API int service_discovery_module::init() {
-  int ret = cluster_context_.init(*get_app(), get_app()->get_origin_configure().etcd(), nullptr);
+  int ret = cluster_context_->init(*get_app(), get_app()->get_origin_configure().etcd(), nullptr);
   if (ret < 0) {
     return ret;
   }
@@ -237,7 +237,7 @@ LIBATAPP_MACRO_API int service_discovery_module::init() {
     return ret;
   }
 
-  if (!cluster_context_.check_keepalive_actor_start_success()) {
+  if (!cluster_context_->check_keepalive_actor_start_success()) {
     stop();
     return -1;
   }
@@ -252,25 +252,30 @@ LIBATAPP_MACRO_API const char *ATFW_UTIL_MACRO_NONNULL service_discovery_module:
 LIBATAPP_MACRO_API service_discovery_module::service_discovery_cluster_context::service_discovery_cluster_context()
     : data_(std::make_shared<service_discovery_cluster_context_data>()) {}
 
-LIBATAPP_MACRO_API int service_discovery_module::stop() { return cluster_context_.stop(); }
+LIBATAPP_MACRO_API int service_discovery_module::stop() { return cluster_context_->stop(); }
 
 LIBATAPP_MACRO_API int service_discovery_module::reload() {
-  return cluster_context_.reload(get_app()->get_origin_configure().etcd(), nullptr);
+  return cluster_context_->reload(get_app()->get_origin_configure().etcd(), nullptr);
 }
 
 LIBATAPP_MACRO_API int service_discovery_module::tick() {
-  cluster_context_.tick();
+  cluster_context_->tick();
 
   update_keepalive_topology_value();
-  if (cluster_context_.get_etcd_module().get_etcd_cluster().check_flag(etcd_cluster::flag_t::kRunning)) {
+  if (cluster_context_->get_etcd_module().get_etcd_cluster().check_flag(etcd_cluster::flag_t::kRunning)) {
     update_keepalive_discovery_value();
   }
 
   return 0;
 }
 
+LIBATAPP_MACRO_API int service_discovery_module::timeout() {
+  cluster_context_->reset();
+  return 0;
+}
+
 LIBATAPP_MACRO_API bool service_discovery_module::is_discovery_enabled() const {
-  return cluster_context_.get_etcd_module().is_etcd_enabled() && discovery_enabled_;
+  return cluster_context_->get_etcd_module().is_etcd_enabled() && discovery_enabled_;
 }
 
 LIBATAPP_MACRO_API void service_discovery_module::enable_discovery() {
@@ -281,7 +286,12 @@ LIBATAPP_MACRO_API void service_discovery_module::enable_discovery() {
   if (!is_discovery_enabled()) {
     return;
   }
-  init_service_discovery_keepalives_watchers(cluster_context_);
+
+  int ret = init_service_discovery_keepalives_watchers(cluster_context_);
+  if (ret < 0) {
+    discovery_enabled_ = false;
+    cluster_context_->reset_internal_watchers_and_keepalives();
+  }
 }
 
 LIBATAPP_MACRO_API void service_discovery_module::disable_discovery() {
@@ -289,7 +299,7 @@ LIBATAPP_MACRO_API void service_discovery_module::disable_discovery() {
     return;
   }
   discovery_enabled_ = false;
-  cluster_context_.reset_internal_watchers_and_keepalives();
+  cluster_context_->reset_internal_watchers_and_keepalives();
 }
 
 void service_discovery_module::update_keepalive_topology_value() {
@@ -313,8 +323,8 @@ void service_discovery_module::update_keepalive_topology_value() {
     internal_keepalive_topology_value_.swap(new_value);
 
     for (std::list<etcd_keepalive::ptr_t>::iterator iter =
-             cluster_context_.data_->internal_topology_keepalive_actors_.begin();
-         iter != cluster_context_.data_->internal_topology_keepalive_actors_.end(); ++iter) {
+             cluster_context_->data_->internal_topology_keepalive_actors_.begin();
+         iter != cluster_context_->data_->internal_topology_keepalive_actors_.end(); ++iter) {
       if (*iter) {
         (*iter)->set_value(internal_keepalive_topology_value_);
       }
@@ -360,8 +370,8 @@ void service_discovery_module::update_keepalive_discovery_value() {
     internal_keepalive_discovery_value_.swap(new_value);
 
     for (std::list<etcd_keepalive::ptr_t>::iterator iter =
-             cluster_context_.data_->internal_discovery_keepalive_actors_.begin();
-         iter != cluster_context_.data_->internal_discovery_keepalive_actors_.end(); ++iter) {
+             cluster_context_->data_->internal_discovery_keepalive_actors_.begin();
+         iter != cluster_context_->data_->internal_discovery_keepalive_actors_.end(); ++iter) {
       if (*iter) {
         (*iter)->set_value(internal_keepalive_discovery_value_);
       }
@@ -370,7 +380,7 @@ void service_discovery_module::update_keepalive_discovery_value() {
 }
 
 LIBATAPP_MACRO_API int service_discovery_module::init_service_discovery_keepalives_watchers(
-    service_discovery_cluster_context &context) {
+    ::atfw::util::nostd::nonnull<std::shared_ptr<service_discovery_cluster_context>> context) {
   // 先刷新topology数据，后刷新discovery数据，以保证策略路由变化时已获取到最新的topology信息
   update_keepalive_topology_value();
   update_keepalive_discovery_value();
@@ -390,15 +400,15 @@ LIBATAPP_MACRO_API int service_discovery_module::init_service_discovery_keepaliv
     return ret;
   }
 
-  ret = add_topology_watcher_callback(nullptr);
+  ret = add_topology_watcher_callback(app, context, nullptr);
   if (ret < 0) {
     return ret;
   }
-  ret = add_discovery_watcher_by_id_callback(nullptr);
+  ret = add_discovery_watcher_by_id_callback(app, context, nullptr);
   if (ret < 0) {
     return ret;
   }
-  ret = add_discovery_watcher_by_name_callback(nullptr);
+  ret = add_discovery_watcher_by_name_callback(app, context, nullptr);
   if (ret < 0) {
     return ret;
   }
@@ -407,56 +417,58 @@ LIBATAPP_MACRO_API int service_discovery_module::init_service_discovery_keepaliv
 }
 
 LIBATAPP_MACRO_API int service_discovery_module::init_discovery_keepalive_by_id(
-    atframework::atapp::app &app, service_discovery_cluster_context &context, std::string &value) {
+    atframework::atapp::app &app,
+    ::atfw::util::nostd::nonnull<std::shared_ptr<service_discovery_cluster_context>> context, std::string &value) {
   atapp::etcd_keepalive::ptr_t actor = add_keepalive_actor(
-      app, context, value, get_discovery_by_id_path(app, context.etcd_module_.get_configure_path()));
+      app, context, value, get_discovery_by_id_path(app, context->etcd_module_.get_configure_path()));
   if (!actor) {
-    LIBATAPP_MACRO_ETCD_CLUSTER_LOG_ERROR(context.etcd_module_.get_etcd_cluster(),
+    LIBATAPP_MACRO_ETCD_CLUSTER_LOG_ERROR(context->etcd_module_.get_etcd_cluster(),
                                           "create etcd_keepalive for by_id index failed.");
     return -1;
   }
 
-  context.data_->internal_discovery_keepalive_actors_.push_back(actor);
-  LIBATAPP_MACRO_ETCD_CLUSTER_LOG_INFO(context.etcd_module_.get_etcd_cluster(),
+  context->data_->internal_discovery_keepalive_actors_.push_back(actor);
+  LIBATAPP_MACRO_ETCD_CLUSTER_LOG_INFO(context->etcd_module_.get_etcd_cluster(),
                                        "create etcd_keepalive {} for by_id index {} success",
                                        reinterpret_cast<const void *>(actor.get()),
-                                       get_discovery_by_id_path(app, context.etcd_module_.get_configure_path()));
+                                       get_discovery_by_id_path(app, context->etcd_module_.get_configure_path()));
   return 0;
 }
 
 LIBATAPP_MACRO_API int service_discovery_module::init_discovery_keepalive_by_name(
-    atframework::atapp::app &app, service_discovery_cluster_context &context, std::string &value) {
+    atframework::atapp::app &app,
+    ::atfw::util::nostd::nonnull<std::shared_ptr<service_discovery_cluster_context>> context, std::string &value) {
   atapp::etcd_keepalive::ptr_t actor = add_keepalive_actor(
-      app, context, value, get_discovery_by_name_path(app, context.etcd_module_.get_configure_path()));
+      app, context, value, get_discovery_by_name_path(app, context->etcd_module_.get_configure_path()));
   if (!actor) {
-    LIBATAPP_MACRO_ETCD_CLUSTER_LOG_ERROR(context.etcd_module_.get_etcd_cluster(),
+    LIBATAPP_MACRO_ETCD_CLUSTER_LOG_ERROR(context->etcd_module_.get_etcd_cluster(),
                                           "create etcd_keepalive for by_name index failed.");
     return -1;
   }
 
-  context.data_->internal_discovery_keepalive_actors_.push_back(actor);
-  LIBATAPP_MACRO_ETCD_CLUSTER_LOG_INFO(context.etcd_module_.get_etcd_cluster(),
+  context->data_->internal_discovery_keepalive_actors_.push_back(actor);
+  LIBATAPP_MACRO_ETCD_CLUSTER_LOG_INFO(context->etcd_module_.get_etcd_cluster(),
                                        "create etcd_keepalive {} for by_name index {} success",
                                        reinterpret_cast<const void *>(actor.get()),
-                                       get_discovery_by_name_path(app, context.etcd_module_.get_configure_path()));
+                                       get_discovery_by_name_path(app, context->etcd_module_.get_configure_path()));
   return 0;
 }
 
-LIBATAPP_MACRO_API int service_discovery_module::init_topology_keepalive(atframework::atapp::app &app,
-                                                                         service_discovery_cluster_context &context,
-                                                                         std::string &value) {
+LIBATAPP_MACRO_API int service_discovery_module::init_topology_keepalive(
+    atframework::atapp::app &app,
+    ::atfw::util::nostd::nonnull<std::shared_ptr<service_discovery_cluster_context>> context, std::string &value) {
   atapp::etcd_keepalive::ptr_t actor =
-      add_keepalive_actor(app, context, value, get_topology_path(app, context.etcd_module_.get_configure_path()));
+      add_keepalive_actor(app, context, value, get_topology_path(app, context->etcd_module_.get_configure_path()));
   if (!actor) {
-    LIBATAPP_MACRO_ETCD_CLUSTER_LOG_ERROR(context.etcd_module_.get_etcd_cluster(),
+    LIBATAPP_MACRO_ETCD_CLUSTER_LOG_ERROR(context->etcd_module_.get_etcd_cluster(),
                                           "create etcd_keepalive for topology index failed.");
     return -1;
   }
 
-  context.data_->internal_topology_keepalive_actors_.push_back(actor);
+  context->data_->internal_topology_keepalive_actors_.push_back(actor);
   LIBATAPP_MACRO_ETCD_CLUSTER_LOG_INFO(
-      context.etcd_module_.get_etcd_cluster(), "create etcd_keepalive {} for topology index {} success",
-      reinterpret_cast<const void *>(actor.get()), get_topology_path(app, context.etcd_module_.get_configure_path()));
+      context->etcd_module_.get_etcd_cluster(), "create etcd_keepalive {} for topology index {} success",
+      reinterpret_cast<const void *>(actor.get()), get_topology_path(app, context->etcd_module_.get_configure_path()));
   return 0;
 }
 
@@ -507,85 +519,88 @@ LIBATAPP_MACRO_API std::string service_discovery_module::get_topology_watcher_pa
 }
 
 LIBATAPP_MACRO_API int service_discovery_module::init_discovery_watcher_by_id(
-    ATFW_EXPLICIT_UNUSED_ATTR atframework::atapp::app &app, service_discovery_cluster_context &context) {
-  if (!context.data_->internal_discovery_watcher_by_id_) {
+    ATFW_EXPLICIT_UNUSED_ATTR atframework::atapp::app &app,
+    ::atfw::util::nostd::nonnull<std::shared_ptr<service_discovery_cluster_context>> context) {
+  if (!context->data_->internal_discovery_watcher_by_id_) {
     std::string watch_path =
-        LOG_WRAPPER_FWAPI_FORMAT("{}{}", context.etcd_module_.get_configure_path(), ETCD_MODULE_BY_ID_DIR);
+        LOG_WRAPPER_FWAPI_FORMAT("{}{}", context->etcd_module_.get_configure_path(), ETCD_MODULE_BY_ID_DIR);
 
-    context.data_->internal_discovery_watcher_by_id_ =
-        atapp::etcd_watcher::create(context.etcd_module_.get_etcd_cluster(), watch_path, "+1");
-    if (!context.data_->internal_discovery_watcher_by_id_) {
-      LIBATAPP_MACRO_ETCD_CLUSTER_LOG_ERROR(context.etcd_module_.get_etcd_cluster(),
+    context->data_->internal_discovery_watcher_by_id_ =
+        atapp::etcd_watcher::create(context->etcd_module_.get_etcd_cluster(), watch_path, "+1");
+    if (!context->data_->internal_discovery_watcher_by_id_) {
+      LIBATAPP_MACRO_ETCD_CLUSTER_LOG_ERROR(context->etcd_module_.get_etcd_cluster(),
                                             "create etcd_watcher by_id failed.");
       return EN_ATBUS_ERR_MALLOC;
     }
 
-    context.data_->internal_discovery_watcher_by_id_->set_conf_from_protobuf(
-        context.etcd_module_.get_configure().watcher());
-    context.etcd_module_.get_etcd_cluster().add_watcher(context.data_->internal_discovery_watcher_by_id_);
-    LIBATAPP_MACRO_ETCD_CLUSTER_LOG_INFO(context.etcd_module_.get_etcd_cluster(),
+    context->data_->internal_discovery_watcher_by_id_->set_conf_from_protobuf(
+        context->etcd_module_.get_configure().watcher());
+    context->etcd_module_.get_etcd_cluster().add_watcher(context->data_->internal_discovery_watcher_by_id_);
+    LIBATAPP_MACRO_ETCD_CLUSTER_LOG_INFO(context->etcd_module_.get_etcd_cluster(),
                                          "create etcd_watcher for by_id index {} success", watch_path);
 
-    context.data_->internal_discovery_watcher_by_id_->set_evt_handle(discovery_watcher_callback_list_wrapper_t(
-        *app.get_service_discovery_module(), context, context.data_->discovery_watcher_callback_lock_,
-        context.data_->discovery_watcher_by_id_callbacks_,
-        ++context.data_->discovery_watcher_snapshot_index_allocator_));
+    context->data_->internal_discovery_watcher_by_id_->set_evt_handle(discovery_watcher_callback_list_wrapper_t(
+        *app.get_service_discovery_module(), context, context->data_->discovery_watcher_callback_lock_,
+        context->data_->discovery_watcher_by_id_callbacks_,
+        ++context->data_->discovery_watcher_snapshot_index_allocator_));
   }
   return 0;
 }
 
 LIBATAPP_MACRO_API int service_discovery_module::init_discovery_watcher_by_name(
-    ATFW_EXPLICIT_UNUSED_ATTR atframework::atapp::app &app, service_discovery_cluster_context &context) {
-  if (!context.data_->internal_discovery_watcher_by_name_) {
+    ATFW_EXPLICIT_UNUSED_ATTR atframework::atapp::app &app,
+    ::atfw::util::nostd::nonnull<std::shared_ptr<service_discovery_cluster_context>> context) {
+  if (!context->data_->internal_discovery_watcher_by_name_) {
     // generate watch data
     std::string watch_path =
-        LOG_WRAPPER_FWAPI_FORMAT("{}{}", context.etcd_module_.get_configure_path(), ETCD_MODULE_BY_NAME_DIR);
+        LOG_WRAPPER_FWAPI_FORMAT("{}{}", context->etcd_module_.get_configure_path(), ETCD_MODULE_BY_NAME_DIR);
 
-    context.data_->internal_discovery_watcher_by_name_ =
-        atapp::etcd_watcher::create(context.etcd_module_.get_etcd_cluster(), watch_path, "+1");
-    if (!context.data_->internal_discovery_watcher_by_name_) {
-      LIBATAPP_MACRO_ETCD_CLUSTER_LOG_ERROR(context.etcd_module_.get_etcd_cluster(),
+    context->data_->internal_discovery_watcher_by_name_ =
+        atapp::etcd_watcher::create(context->etcd_module_.get_etcd_cluster(), watch_path, "+1");
+    if (!context->data_->internal_discovery_watcher_by_name_) {
+      LIBATAPP_MACRO_ETCD_CLUSTER_LOG_ERROR(context->etcd_module_.get_etcd_cluster(),
                                             "create etcd_watcher by_name failed.");
       return EN_ATBUS_ERR_MALLOC;
     }
 
-    context.data_->internal_discovery_watcher_by_name_->set_conf_from_protobuf(
-        context.etcd_module_.get_configure().watcher());
-    context.etcd_module_.get_etcd_cluster().add_watcher(context.data_->internal_discovery_watcher_by_name_);
-    LIBATAPP_MACRO_ETCD_CLUSTER_LOG_INFO(context.etcd_module_.get_etcd_cluster(),
+    context->data_->internal_discovery_watcher_by_name_->set_conf_from_protobuf(
+        context->etcd_module_.get_configure().watcher());
+    context->etcd_module_.get_etcd_cluster().add_watcher(context->data_->internal_discovery_watcher_by_name_);
+    LIBATAPP_MACRO_ETCD_CLUSTER_LOG_INFO(context->etcd_module_.get_etcd_cluster(),
                                          "create etcd_watcher for by_name index {} success", watch_path);
 
-    context.data_->internal_discovery_watcher_by_name_->set_evt_handle(discovery_watcher_callback_list_wrapper_t(
-        *app.get_service_discovery_module(), context, context.data_->discovery_watcher_callback_lock_,
-        context.data_->discovery_watcher_by_name_callbacks_,
-        ++context.data_->discovery_watcher_snapshot_index_allocator_));
+    context->data_->internal_discovery_watcher_by_name_->set_evt_handle(discovery_watcher_callback_list_wrapper_t(
+        *app.get_service_discovery_module(), context, context->data_->discovery_watcher_callback_lock_,
+        context->data_->discovery_watcher_by_name_callbacks_,
+        ++context->data_->discovery_watcher_snapshot_index_allocator_));
   }
   return 0;
 }
 
 LIBATAPP_MACRO_API int service_discovery_module::init_topology_watcher(
-    ATFW_EXPLICIT_UNUSED_ATTR atframework::atapp::app &app, service_discovery_cluster_context &context) {
-  if (!context.data_->internal_topology_watcher_) {
+    ATFW_EXPLICIT_UNUSED_ATTR atframework::atapp::app &app,
+    ::atfw::util::nostd::nonnull<std::shared_ptr<service_discovery_cluster_context>> context) {
+  if (!context->data_->internal_topology_watcher_) {
     // generate watch data
     std::string watch_path =
-        LOG_WRAPPER_FWAPI_FORMAT("{}{}", context.etcd_module_.get_configure_path(), ETCD_MODULE_TOPOLOGY_DIR);
+        LOG_WRAPPER_FWAPI_FORMAT("{}{}", context->etcd_module_.get_configure_path(), ETCD_MODULE_TOPOLOGY_DIR);
 
-    context.data_->internal_topology_watcher_ =
-        atapp::etcd_watcher::create(context.etcd_module_.get_etcd_cluster(), watch_path, "+1");
-    if (!context.data_->internal_topology_watcher_) {
-      LIBATAPP_MACRO_ETCD_CLUSTER_LOG_ERROR(context.etcd_module_.get_etcd_cluster(),
+    context->data_->internal_topology_watcher_ =
+        atapp::etcd_watcher::create(context->etcd_module_.get_etcd_cluster(), watch_path, "+1");
+    if (!context->data_->internal_topology_watcher_) {
+      LIBATAPP_MACRO_ETCD_CLUSTER_LOG_ERROR(context->etcd_module_.get_etcd_cluster(),
                                             "create etcd_watcher topology failed.");
       return EN_ATBUS_ERR_MALLOC;
     }
 
-    context.data_->internal_topology_watcher_->set_conf_from_protobuf(context.etcd_module_.get_configure().watcher());
-    context.etcd_module_.get_etcd_cluster().add_watcher(context.data_->internal_topology_watcher_);
-    LIBATAPP_MACRO_ETCD_CLUSTER_LOG_INFO(context.etcd_module_.get_etcd_cluster(),
+    context->data_->internal_topology_watcher_->set_conf_from_protobuf(context->etcd_module_.get_configure().watcher());
+    context->etcd_module_.get_etcd_cluster().add_watcher(context->data_->internal_topology_watcher_);
+    LIBATAPP_MACRO_ETCD_CLUSTER_LOG_INFO(context->etcd_module_.get_etcd_cluster(),
                                          "create etcd_watcher for topology index {} success", watch_path);
 
-    context.data_->internal_topology_watcher_->set_evt_handle(topology_watcher_callback_list_wrapper_t(
-        *app.get_service_discovery_module(), context, context.data_->topology_watcher_callback_lock_,
-        context.data_->topology_watcher_callbacks_, ++context.data_->topology_watcher_snapshot_index_allocator_));
+    context->data_->internal_topology_watcher_->set_evt_handle(topology_watcher_callback_list_wrapper_t(
+        *app.get_service_discovery_module(), context, context->data_->topology_watcher_callback_lock_,
+        context->data_->topology_watcher_callbacks_, ++context->data_->topology_watcher_snapshot_index_allocator_));
   }
   return 0;
 }
@@ -608,6 +623,8 @@ LIBATAPP_MACRO_API int service_discovery_module::service_discovery_cluster_conte
 
 LIBATAPP_MACRO_API void service_discovery_module::service_discovery_cluster_context::tick() { etcd_module_.tick(); }
 
+LIBATAPP_MACRO_API void service_discovery_module::service_discovery_cluster_context::reset() { etcd_module_.reset(); }
+
 LIBATAPP_MACRO_API etcd_module &service_discovery_module::service_discovery_cluster_context::get_etcd_module() {
   return etcd_module_;
 }
@@ -652,50 +669,56 @@ LIBATAPP_MACRO_API void service_discovery_module::service_discovery_cluster_cont
 }
 
 LIBATAPP_MACRO_API int service_discovery_module::add_discovery_watcher_by_id_callback(
+    atframework::atapp::app &app,
+    ::atfw::util::nostd::nonnull<std::shared_ptr<service_discovery_cluster_context>> context,
     const discovery_watcher_list_callback_t &fn) {
-  int ret = init_discovery_watcher_by_id(*get_app(), cluster_context_);
+  int ret = init_discovery_watcher_by_id(app, context);
   if (ret < 0) {
     return ret;
   }
-  cluster_context_.add_discovery_watcher_by_id_callback(fn);
+  context->add_discovery_watcher_by_id_callback(fn);
   return 0;
 }
 
 LIBATAPP_MACRO_API int service_discovery_module::add_discovery_watcher_by_name_callback(
+    atframework::atapp::app &app,
+    ::atfw::util::nostd::nonnull<std::shared_ptr<service_discovery_cluster_context>> context,
     const discovery_watcher_list_callback_t &fn) {
-  int ret = init_discovery_watcher_by_name(*get_app(), cluster_context_);
+  int ret = init_discovery_watcher_by_name(app, context);
   if (ret < 0) {
     return ret;
   }
-  cluster_context_.add_discovery_watcher_by_name_callback(fn);
+  context->add_discovery_watcher_by_name_callback(fn);
   return 0;
 }
 
 LIBATAPP_MACRO_API int service_discovery_module::add_topology_watcher_callback(
+    atframework::atapp::app &app,
+    ::atfw::util::nostd::nonnull<std::shared_ptr<service_discovery_cluster_context>> context,
     const topology_watcher_list_callback_t &fn) {
-  int ret = init_topology_watcher(*get_app(), cluster_context_);
+  int ret = init_topology_watcher(app, context);
   if (ret < 0) {
     return ret;
   }
-  cluster_context_.add_topology_watcher_callback(fn);
+  context->add_topology_watcher_callback(fn);
   return 0;
 }
 
 LIBATAPP_MACRO_API const ::atframework::atapp::etcd_cluster &service_discovery_module::get_raw_etcd_ctx() const {
-  return cluster_context_.get_etcd_module().get_etcd_cluster();
+  return cluster_context_->get_etcd_module().get_etcd_cluster();
 }
 LIBATAPP_MACRO_API ::atframework::atapp::etcd_cluster &service_discovery_module::get_raw_etcd_ctx() {
-  return cluster_context_.get_etcd_module().get_etcd_cluster();
+  return cluster_context_->get_etcd_module().get_etcd_cluster();
 }
 
 LIBATAPP_MACRO_API const ::atframework::atapp::etcd_response_header &
 service_discovery_module::get_last_etcd_event_topology_header() const noexcept {
-  return cluster_context_.data_->last_etcd_event_topology_header_;
+  return cluster_context_->data_->last_etcd_event_topology_header_;
 }
 
 LIBATAPP_MACRO_API const ::atframework::atapp::etcd_response_header &
 service_discovery_module::get_last_etcd_event_discovery_header() const noexcept {
-  return cluster_context_.data_->last_etcd_event_discovery_header_;
+  return cluster_context_->data_->last_etcd_event_discovery_header_;
 }
 
 LIBATAPP_MACRO_API const atapp::protocol::atapp_etcd &service_discovery_module::get_configure() const {
@@ -703,11 +726,12 @@ LIBATAPP_MACRO_API const atapp::protocol::atapp_etcd &service_discovery_module::
 }
 
 LIBATAPP_MACRO_API const std::string &service_discovery_module::get_configure_path() {
-  return cluster_context_.get_etcd_module().get_configure_path();
+  return cluster_context_->get_etcd_module().get_configure_path();
 }
 
 LIBATAPP_MACRO_API atapp::etcd_keepalive::ptr_t service_discovery_module::add_keepalive_actor(
-    atframework::atapp::app &app, service_discovery_cluster_context &context, std::string &val,
+    atframework::atapp::app &app,
+    ::atfw::util::nostd::nonnull<std::shared_ptr<service_discovery_cluster_context>> context, std::string &val,
     const std::string &node_path) {
   atapp::etcd_keepalive::ptr_t ret;
 
@@ -717,16 +741,16 @@ LIBATAPP_MACRO_API atapp::etcd_keepalive::ptr_t service_discovery_module::add_ke
     pack(ni, val);
   }
 
-  ret = atapp::etcd_keepalive::create(context.etcd_module_.get_etcd_cluster(), node_path);
+  ret = atapp::etcd_keepalive::create(context->etcd_module_.get_etcd_cluster(), node_path);
   if (!ret) {
-    LIBATAPP_MACRO_ETCD_CLUSTER_LOG_ERROR(context.etcd_module_.get_etcd_cluster(), "create etcd_keepalive failed.");
+    LIBATAPP_MACRO_ETCD_CLUSTER_LOG_ERROR(context->etcd_module_.get_etcd_cluster(), "create etcd_keepalive failed.");
     return ret;
   }
 
   ret->set_checker(val);
   ret->set_value(val);
 
-  if (!context.etcd_module_.get_etcd_cluster().add_keepalive(ret)) {
+  if (!context->etcd_module_.get_etcd_cluster().add_keepalive(ret)) {
     ret.reset();
   }
 
@@ -739,19 +763,21 @@ LIBATAPP_MACRO_API atapp::etcd_keepalive::ptr_t service_discovery_module::add_ke
 }
 
 LIBATAPP_MACRO_API bool service_discovery_module::remove_keepalive_actor(
-    ATFW_EXPLICIT_UNUSED_ATTR atframework::atapp::app &app, service_discovery_cluster_context &context,
+    ATFW_EXPLICIT_UNUSED_ATTR atframework::atapp::app &app,
+    ::atfw::util::nostd::nonnull<std::shared_ptr<service_discovery_cluster_context>> context,
     const atapp::etcd_keepalive::ptr_t &keepalive) {
   if (!keepalive) {
     return false;
   }
 
-  return context.etcd_module_.get_etcd_cluster().remove_keepalive(keepalive);
+  return context->etcd_module_.get_etcd_cluster().remove_keepalive(keepalive);
 }
 
 LIBATAPP_MACRO_API bool service_discovery_module::remove_keepalive_actor(
     atframework::atapp::app &app, const atapp::etcd_keepalive::ptr_t &keepalive) {
-  std::list<etcd_keepalive::ptr_t> *keepalive_actors[] = {&cluster_context_.data_->internal_discovery_keepalive_actors_,
-                                                          &cluster_context_.data_->internal_topology_keepalive_actors_};
+  std::list<etcd_keepalive::ptr_t> *keepalive_actors[] = {
+      &cluster_context_->data_->internal_discovery_keepalive_actors_,
+      &cluster_context_->data_->internal_topology_keepalive_actors_};
 
   for (auto *keepalive_actor_list : keepalive_actors) {
     std::list<etcd_keepalive::ptr_t>::iterator internal_iter =
@@ -818,7 +844,7 @@ service_discovery_module::get_topology_info_set() const noexcept {
 }
 
 LIBATAPP_MACRO_API bool service_discovery_module::has_discovery_snapshot() const noexcept {
-  return !cluster_context_.data_->discovery_watcher_snapshot_index_.empty();
+  return !cluster_context_->data_->discovery_watcher_snapshot_index_.empty();
 }
 
 LIBATAPP_MACRO_API service_discovery_module::discovery_snapshot_event_callback_handle_t
@@ -860,7 +886,7 @@ LIBATAPP_MACRO_API void service_discovery_module::remove_on_discovery_snapshot_l
 }
 
 LIBATAPP_MACRO_API bool service_discovery_module::has_topology_snapshot() const noexcept {
-  return !cluster_context_.data_->topology_watcher_snapshot_index_.empty();
+  return !cluster_context_->data_->topology_watcher_snapshot_index_.empty();
 }
 
 LIBATAPP_MACRO_API service_discovery_module::topology_snapshot_event_callback_handle_t
@@ -902,14 +928,16 @@ LIBATAPP_MACRO_API void service_discovery_module::remove_on_topology_snapshot_lo
 }
 
 LIBATAPP_MACRO_API etcd_watcher::watch_event_fn_t_ptr
-service_discovery_module::create_discovery_watcher_callback_list_wrapper(service_discovery_cluster_context &context) {
+service_discovery_module::create_discovery_watcher_callback_list_wrapper(
+    ::atfw::util::nostd::nonnull<std::shared_ptr<service_discovery_cluster_context>> context) {
   return std::make_unique<etcd_watcher::watch_event_fn_t>(discovery_watcher_callback_list_wrapper_t(
-      *this, context, ++context.data_->discovery_watcher_snapshot_index_allocator_));
+      *this, context, ++context->data_->discovery_watcher_snapshot_index_allocator_));
 }
 LIBATAPP_MACRO_API etcd_watcher::watch_event_fn_t_ptr
-service_discovery_module::create_topology_watcher_callback_list_wrapper(service_discovery_cluster_context &context) {
+service_discovery_module::create_topology_watcher_callback_list_wrapper(
+    ::atfw::util::nostd::nonnull<std::shared_ptr<service_discovery_cluster_context>> context) {
   return std::make_unique<etcd_watcher::watch_event_fn_t>(topology_watcher_callback_list_wrapper_t(
-      *this, context, ++context.data_->topology_watcher_snapshot_index_allocator_));
+      *this, context, ++context->data_->topology_watcher_snapshot_index_allocator_));
 }
 
 bool service_discovery_module::unpack(node_info_t &out, const std::string &path, const std::string &json,
@@ -1052,23 +1080,25 @@ void service_discovery_module::watcher_internal_access_t::cleanup_old_nodes(
     service_discovery_module &mod, service_discovery_cluster_context &ctx,
     etcd_discovery_set::node_by_name_type &old_names, etcd_discovery_set::node_by_id_type &old_ids) {
   for (auto &node : old_names) {
-    if (node.second->get_context_ptr() != reinterpret_cast<uintptr_t>(&ctx)) {
+    if (node.second->get_context_addr() != reinterpret_cast<uintptr_t>(&ctx)) {
+      // 只有相同 context 才会进行清理
       continue;
     }
     service_discovery_module::node_info_t evt_node;
     evt_node.action = service_discovery_module::node_action_t::kDelete;
-    evt_node.context_ptr = reinterpret_cast<uintptr_t>(&ctx);
+    evt_node.context_addr = reinterpret_cast<uintptr_t>(&ctx);
     node.second->copy_key_to(evt_node.node_discovery);
     mod.update_internal_watcher_event(evt_node, node.second->get_version());
   }
 
   for (auto &node : old_ids) {
-    if (node.second->get_context_ptr() != reinterpret_cast<uintptr_t>(&ctx)) {
+    if (node.second->get_context_addr() != reinterpret_cast<uintptr_t>(&ctx)) {
+      // 只有相同 context 才会进行清理
       continue;
     }
     service_discovery_module::node_info_t evt_node;
     evt_node.action = service_discovery_module::node_action_t::kDelete;
-    evt_node.context_ptr = reinterpret_cast<uintptr_t>(&ctx);
+    evt_node.context_addr = reinterpret_cast<uintptr_t>(&ctx);
     node.second->copy_key_to(evt_node.node_discovery);
     mod.update_internal_watcher_event(evt_node, node.second->get_version());
   }
@@ -1095,7 +1125,8 @@ void service_discovery_module::watcher_internal_access_t::cleanup_old_topology_p
     service_discovery_module &mod, service_discovery_cluster_context &ctx,
     std::unordered_map<uint64_t, service_discovery_module::topology_storage_t> &old_ids) {
   for (auto &id : old_ids) {
-    if (id.second.context_ptr != reinterpret_cast<uintptr_t>(&ctx)) {
+    if (id.second.context_addr != reinterpret_cast<uintptr_t>(&ctx)) {
+      // 只有相同 context 才会进行清理
       continue;
     }
     service_discovery_module::topology_info_t evt_node;
@@ -1106,19 +1137,20 @@ void service_discovery_module::watcher_internal_access_t::cleanup_old_topology_p
 }
 
 service_discovery_module::discovery_watcher_callback_list_wrapper_t::discovery_watcher_callback_list_wrapper_t(
-    service_discovery_module &m, service_discovery_cluster_context &c, int64_t index)
+    service_discovery_module &m, ::atfw::util::nostd::nonnull<std::shared_ptr<service_discovery_cluster_context>> c,
+    int64_t index)
     : mod(&m),
-      ctx(&c),
+      ctx(c),
       callback_lock(nullptr),
       callbacks(nullptr),
       snapshot_index(index),
       has_insert_snapshot_index(false) {}
 
 service_discovery_module::discovery_watcher_callback_list_wrapper_t::discovery_watcher_callback_list_wrapper_t(
-    service_discovery_module &m, service_discovery_cluster_context &c, std::recursive_mutex &lock,
-    std::list<discovery_watcher_list_callback_t> &cbks, int64_t index)
+    service_discovery_module &m, ::atfw::util::nostd::nonnull<std::shared_ptr<service_discovery_cluster_context>> c,
+    std::recursive_mutex &lock, std::list<discovery_watcher_list_callback_t> &cbks, int64_t index)
     : mod(&m),
-      ctx(&c),
+      ctx(c),
       callback_lock(&lock),
       callbacks(&cbks),
       snapshot_index(index),
@@ -1172,7 +1204,7 @@ void service_discovery_module::discovery_watcher_callback_list_wrapper_t::operat
   for (size_t i = 0; i < body.events.size(); ++i) {
     const ::atframework::atapp::etcd_watcher::event_t &evt_data = body.events[i];
     node_info_t node;
-    node.context_ptr = reinterpret_cast<uintptr_t>(ctx);
+    node.context_addr = reinterpret_cast<uintptr_t>(ctx.get());
     etcd_discovery_node::node_version current_node_version;
 
     unpack(node, evt_data.kv.key.empty() ? evt_data.prev_kv.key : evt_data.kv.key,
@@ -1231,19 +1263,20 @@ void service_discovery_module::discovery_watcher_callback_list_wrapper_t::operat
 }
 
 service_discovery_module::topology_watcher_callback_list_wrapper_t::topology_watcher_callback_list_wrapper_t(
-    service_discovery_module &m, service_discovery_cluster_context &c, int64_t index)
+    service_discovery_module &m, ::atfw::util::nostd::nonnull<std::shared_ptr<service_discovery_cluster_context>> c,
+    int64_t index)
     : mod(&m),
-      ctx(&c),
+      ctx(c),
       callback_lock(nullptr),
       callbacks(nullptr),
       snapshot_index(index),
       has_insert_snapshot_index(false) {}
 
 service_discovery_module::topology_watcher_callback_list_wrapper_t::topology_watcher_callback_list_wrapper_t(
-    service_discovery_module &m, service_discovery_cluster_context &c, std::recursive_mutex &lock,
-    std::list<topology_watcher_list_callback_t> &cbks, int64_t index)
+    service_discovery_module &m, ::atfw::util::nostd::nonnull<std::shared_ptr<service_discovery_cluster_context>> c,
+    std::recursive_mutex &lock, std::list<topology_watcher_list_callback_t> &cbks, int64_t index)
     : mod(&m),
-      ctx(&c),
+      ctx(c),
       callback_lock(&lock),
       callbacks(&cbks),
       snapshot_index(index),
@@ -1296,7 +1329,7 @@ void service_discovery_module::topology_watcher_callback_list_wrapper_t::operato
   for (size_t i = 0; i < body.events.size(); ++i) {
     const ::atframework::atapp::etcd_watcher::event_t &evt_data = body.events[i];
     topology_info_t topology_info;
-    topology_info.storage.context_ptr = reinterpret_cast<uintptr_t>(ctx);
+    topology_info.storage.context_addr = reinterpret_cast<uintptr_t>(ctx.get());
 
     unpack(topology_info, evt_data.kv.key.empty() ? evt_data.prev_kv.key : evt_data.kv.key,
            evt_data.kv.value.empty() ? evt_data.prev_kv.value : evt_data.kv.value, true);
@@ -1360,16 +1393,37 @@ bool service_discovery_module::update_internal_watcher_event(node_info_t &node,
   if ATFW_UTIL_LIKELY_CONDITION (local_cache_by_id == local_cache_by_name) {
     if (node_action_t::kDelete == node.action) {
       if (local_cache_by_id) {
-        local_cache_by_id->update_version(version, true, node.context_ptr);
+        if (local_cache_by_id->get_context_addr() != node.context_addr) {
+          // 只有相同 context 才进行处理
+          LIBATAPP_MACRO_ETCD_CLUSTER_LOG_WARNING(
+              cluster_context_->etcd_module_.get_etcd_cluster(),
+              "try to delete node with same id but different context, ignore it. node id: %lu, node name: %s, node "
+              "context: %p, local cache context: %p",
+              node.node_discovery.id(), node.node_discovery.name().c_str(), reinterpret_cast<void *>(node.context_addr),
+              reinterpret_cast<void *>(local_cache_by_id->get_context_addr()));
+          return false;
+        }
+        local_cache_by_id->update_version(version, true);
         global_discovery_.remove_node(local_cache_by_id);
 
         has_event = true;
       }
     } else {
-      if (local_cache_by_id && protobuf_equal(local_cache_by_id->get_discovery_info(), node.node_discovery) &&
-          local_cache_by_id->get_context_ptr() == node.context_ptr) {
-        local_cache_by_id->update_version(version, false, node.context_ptr);
-        return false;
+      if (local_cache_by_id) {
+        if (local_cache_by_id->get_context_addr() != node.context_addr) {
+          // 只有相同 context 才进行处理
+          LIBATAPP_MACRO_ETCD_CLUSTER_LOG_WARNING(
+              cluster_context_->etcd_module_.get_etcd_cluster(),
+              "try to delete node with same id but different context, ignore it. node id: %lu, node name: %s, node "
+              "context: %p, local cache context: %p",
+              node.node_discovery.id(), node.node_discovery.name().c_str(), reinterpret_cast<void *>(node.context_addr),
+              reinterpret_cast<void *>(local_cache_by_id->get_context_addr()));
+          return false;
+        }
+        if (protobuf_equal(local_cache_by_id->get_discovery_info(), node.node_discovery)) {
+          local_cache_by_id->update_version(version, true);
+          return false;
+        }
       }
 
       if (local_cache_by_id) {
@@ -1378,7 +1432,7 @@ bool service_discovery_module::update_internal_watcher_event(node_info_t &node,
         new_inst = atfw::util::memory::make_strong_rc<etcd_discovery_node>();
       }
 
-      new_inst->copy_from(node.node_discovery, version, node.context_ptr);
+      new_inst->copy_from(node.node_discovery, version, node.context_addr);
       global_discovery_.add_node(new_inst);
 
       has_event = true;
@@ -1386,27 +1440,49 @@ bool service_discovery_module::update_internal_watcher_event(node_info_t &node,
   } else {
     if (node_action_t::kDelete == node.action) {
       if (local_cache_by_id) {
-        local_cache_by_id->update_version(version, true, node.context_ptr);
-        global_discovery_.remove_node(local_cache_by_id);
-        has_event = true;
+        if (local_cache_by_id->get_context_addr() != node.context_addr) {
+          // 只有相同 context 才进行处理
+          LIBATAPP_MACRO_ETCD_CLUSTER_LOG_WARNING(
+              cluster_context_->etcd_module_.get_etcd_cluster(),
+              "try to delete node with same id but different context, ignore it. node id: %lu, node name: %s, node "
+              "context: %p, local cache context: %p",
+              node.node_discovery.id(), node.node_discovery.name().c_str(), reinterpret_cast<void *>(node.context_addr),
+              reinterpret_cast<void *>(local_cache_by_id->get_context_addr()));
+          local_cache_by_id = nullptr;
+        } else {
+          local_cache_by_id->update_version(version, true);
+          global_discovery_.remove_node(local_cache_by_id);
+          has_event = true;
+        }
       }
       if (local_cache_by_name) {
-        local_cache_by_name->update_version(version, true, node.context_ptr);
-        global_discovery_.remove_node(local_cache_by_name);
-        has_event = true;
+        if (local_cache_by_name->get_context_addr() != node.context_addr) {
+          // 只有相同 context 才进行处理
+          LIBATAPP_MACRO_ETCD_CLUSTER_LOG_WARNING(
+              cluster_context_->etcd_module_.get_etcd_cluster(),
+              "try to delete node with same name but different context, ignore it. node id: %lu, node name: %s, node "
+              "context: %p, local cache context: %p",
+              node.node_discovery.id(), node.node_discovery.name().c_str(), reinterpret_cast<void *>(node.context_addr),
+              reinterpret_cast<void *>(local_cache_by_name->get_context_addr()));
+          local_cache_by_name = nullptr;
+        } else {
+          local_cache_by_name->update_version(version, true);
+          global_discovery_.remove_node(local_cache_by_name);
+          has_event = true;
+        }
       }
     } else {
       if ((!local_cache_by_id && 0 != node.node_discovery.id()) ||
           (!local_cache_by_name && !node.node_discovery.name().empty())) {
         has_event = true;
       } else if (local_cache_by_id &&
-                 (false == protobuf_equal(local_cache_by_id->get_discovery_info(), node.node_discovery) ||
-                  local_cache_by_id->get_context_ptr() != node.context_ptr)) {
+                 (false == protobuf_equal(local_cache_by_id->get_discovery_info(), node.node_discovery) &&
+                  local_cache_by_id->get_context_addr() == node.context_addr)) {
         new_inst = local_cache_by_id;
         has_event = true;
       } else if (local_cache_by_name &&
-                 (false == protobuf_equal(local_cache_by_name->get_discovery_info(), node.node_discovery) ||
-                  local_cache_by_name->get_context_ptr() != node.context_ptr)) {
+                 (false == protobuf_equal(local_cache_by_name->get_discovery_info(), node.node_discovery) &&
+                  local_cache_by_name->get_context_addr() == node.context_addr)) {
         new_inst = local_cache_by_name;
         has_event = true;
       }
@@ -1415,17 +1491,16 @@ bool service_discovery_module::update_internal_watcher_event(node_info_t &node,
         if (!new_inst) {
           new_inst = atfw::util::memory::make_strong_rc<etcd_discovery_node>();
         }
-        new_inst->copy_from(node.node_discovery, version, node.context_ptr);
+        new_inst->copy_from(node.node_discovery, version, node.context_addr);
 
         if (local_cache_by_id && local_cache_by_id != new_inst) {
-          local_cache_by_id->update_version(version, false, node.context_ptr);
+          local_cache_by_id->update_version(version, false);
           global_discovery_.remove_node(local_cache_by_id);
         }
         if (local_cache_by_name && local_cache_by_name != new_inst) {
-          local_cache_by_name->update_version(version, false, node.context_ptr);
+          local_cache_by_name->update_version(version, false);
           global_discovery_.remove_node(local_cache_by_name);
         }
-
         global_discovery_.add_node(new_inst);
       }
     }
@@ -1491,14 +1566,27 @@ bool service_discovery_module::update_internal_watcher_event(topology_info_t &to
       return false;
     }
 
+    if (local_cache_iter->second.context_addr != topology_info.storage.context_addr) {
+      return false;
+    }
+
     info_ptr = local_cache_iter->second.info;
     internal_topology_info_set_.erase(local_cache_iter);
   } else {
     std::unordered_map<uint64_t, topology_storage_t>::iterator local_cache_iter =
         internal_topology_info_set_.find(topology_info.storage.info->id());
     if (local_cache_iter != internal_topology_info_set_.end()) {
-      bool changed = topology_update_version(local_cache_iter->second, topology_info.storage.version, true,
-                                             topology_info.storage.context_ptr);
+      if (local_cache_iter->second.context_addr != topology_info.storage.context_addr) {
+        // 已存在的节点不属于当前 context，视为过期或乱序事件，不触发回调
+        LIBATAPP_MACRO_ETCD_CLUSTER_LOG_WARNING(
+            cluster_context_->etcd_module_.get_etcd_cluster(),
+            "Received topology event with id %lu from context %p, but current context is %p, ignore it",
+            topology_info.storage.info->id(), (void *)topology_info.storage.context_addr,
+            (void *)local_cache_iter->second.context_addr);
+        return false;
+      }
+
+      bool changed = topology_update_version(local_cache_iter->second, topology_info.storage.version, true);
 
       // 未变化
       if (local_cache_iter->second.info &&
@@ -1549,6 +1637,17 @@ void service_discovery_module::service_discovery_cluster_context::reset_internal
     data_->internal_topology_watcher_.reset();
   }
 
+  for (auto &ka : data_->internal_discovery_keepalive_actors_) {
+    if (ka) {
+      etcd_module_.get_etcd_cluster().remove_keepalive(ka);
+    }
+  }
+  for (auto &ka : data_->internal_topology_keepalive_actors_) {
+    if (ka) {
+      etcd_module_.get_etcd_cluster().remove_keepalive(ka);
+    }
+  }
+
   data_->internal_discovery_keepalive_actors_.clear();
   data_->internal_topology_keepalive_actors_.clear();
 }
diff --git a/test/case/atapp_discovery_test.cpp b/test/case/atapp_discovery_test.cpp
index a0662b1..4041ef7 100644
--- a/test/case/atapp_discovery_test.cpp
+++ b/test/case/atapp_discovery_test.cpp
@@ -470,7 +470,7 @@ CASE_TEST(atapp_discovery, discovery_node_version_stale_skip) {
   stale_ver.create_revision = 5;
   stale_ver.modify_revision = 15;  // lower than current 20
   stale_ver.version = 1;           // lower than current 3
-  node->update_version(stale_ver, true, 0);
+  node->update_version(stale_ver, true);
 
   // Version fields should NOT have decreased
   CASE_EXPECT_EQ(10, node->get_version().create_revision);
@@ -482,7 +482,7 @@ CASE_TEST(atapp_discovery, discovery_node_version_stale_skip) {
   newer_ver.create_revision = 10;
   newer_ver.modify_revision = 30;
   newer_ver.version = 5;
-  node->update_version(newer_ver, true, 0);
+  node->update_version(newer_ver, true);
 
   CASE_EXPECT_EQ(30, node->get_version().modify_revision);
   CASE_EXPECT_EQ(5, node->get_version().version);
diff --git a/test/case/atapp_etcd_module_test.cpp b/test/case/atapp_etcd_module_test.cpp
index 24c693d..b236987 100644
--- a/test/case/atapp_etcd_module_test.cpp
+++ b/test/case/atapp_etcd_module_test.cpp
@@ -17,6 +17,8 @@
 #include <cstdlib>
 #include <memory>
 #include <string>
+#include <unordered_map>
+#include <unordered_set>
 #include <vector>
 
 #include "frame/test_macros.h"
@@ -202,9 +204,12 @@ CASE_TEST(atapp_etcd_module, watcher_paths) {
   }
 
   // Watcher paths should be prefix paths (without node-specific suffix)
-  std::string by_id_watcher = discovery_module->get_discovery_by_id_watcher_path(app1, discovery_module->get_configure_path());
-  std::string by_name_watcher = discovery_module->get_discovery_by_name_watcher_path(app1, discovery_module->get_configure_path());
-  std::string topology_watcher = discovery_module->get_topology_watcher_path(app1, discovery_module->get_configure_path());
+  std::string by_id_watcher =
+      discovery_module->get_discovery_by_id_watcher_path(app1, discovery_module->get_configure_path());
+  std::string by_name_watcher =
+      discovery_module->get_discovery_by_name_watcher_path(app1, discovery_module->get_configure_path());
+  std::string topology_watcher =
+      discovery_module->get_topology_watcher_path(app1, discovery_module->get_configure_path());
 
   CASE_EXPECT_FALSE(by_id_watcher.empty());
   CASE_EXPECT_FALSE(by_name_watcher.empty());
@@ -220,9 +225,12 @@ CASE_TEST(atapp_etcd_module, watcher_paths) {
 
   // Watcher paths should NOT contain the app name (they watch the whole prefix)
   // The keepalive paths should be longer (have the app-specific suffix)
-  CASE_EXPECT_LT(by_id_watcher.size(), discovery_module->get_discovery_by_id_path(app1, discovery_module->get_configure_path()).size());
-  CASE_EXPECT_LT(by_name_watcher.size(), discovery_module->get_discovery_by_name_path(app1, discovery_module->get_configure_path()).size());
-  CASE_EXPECT_LT(topology_watcher.size(), discovery_module->get_topology_path(app1, discovery_module->get_configure_path()).size());
+  CASE_EXPECT_LT(by_id_watcher.size(),
+                 discovery_module->get_discovery_by_id_path(app1, discovery_module->get_configure_path()).size());
+  CASE_EXPECT_LT(by_name_watcher.size(),
+                 discovery_module->get_discovery_by_name_path(app1, discovery_module->get_configure_path()).size());
+  CASE_EXPECT_LT(topology_watcher.size(),
+                 discovery_module->get_topology_path(app1, discovery_module->get_configure_path()).size());
 }
 
 // ============================================================
@@ -306,10 +314,12 @@ CASE_TEST(atapp_etcd_module, discovery_snapshot) {
   }
 
   std::vector<atframework::atapp::app *> apps = {&app1};
-  bool has_snapshot = run_apps_until(apps, [&discovery_module]() { return discovery_module->has_discovery_snapshot(); });
+  bool has_snapshot =
+      run_apps_until(apps, [&discovery_module]() { return discovery_module->has_discovery_snapshot(); });
 
   CASE_EXPECT_TRUE(has_snapshot);
-  CASE_MSG_INFO() << "has_discovery_snapshot: " << (discovery_module->has_discovery_snapshot() ? "true" : "false") << '\n';
+  CASE_MSG_INFO() << "has_discovery_snapshot: " << (discovery_module->has_discovery_snapshot() ? "true" : "false")
+                  << '\n';
 }
 
 // ============================================================
@@ -344,7 +354,8 @@ CASE_TEST(atapp_etcd_module, topology_snapshot) {
   bool has_snapshot = run_apps_until(apps, [&discovery_module]() { return discovery_module->has_topology_snapshot(); });
 
   CASE_EXPECT_TRUE(has_snapshot);
-  CASE_MSG_INFO() << "has_topology_snapshot: " << (discovery_module->has_topology_snapshot() ? "true" : "false") << '\n';
+  CASE_MSG_INFO() << "has_topology_snapshot: " << (discovery_module->has_topology_snapshot() ? "true" : "false")
+                  << '\n';
 }
 
 // ============================================================
@@ -1059,7 +1070,7 @@ CASE_TEST(atapp_etcd_module, discovery_event_delete) {
   // Track app2-specific put event to avoid self-registration/refresh noise
   std::string app2_name;
   uint64_t app2_id = 0;
-  std::map<uint64_t, atapp::etcd_discovery_node::ptr_t> id_node_map;
+  std::unordered_map<uint64_t, atapp::etcd_discovery_node::ptr_t> id_node_map;
 
   auto handle = discovery_module1->add_on_node_discovery_event(
       [&](atapp::service_discovery_module::node_action_t action, const atapp::etcd_discovery_node::ptr_t &node) {
@@ -1098,7 +1109,7 @@ CASE_TEST(atapp_etcd_module, discovery_event_delete) {
     bool got_put = run_apps_until(apps, [&id_node_map, app2_id]() { return id_node_map.count(app2_id) > 0; });
     CASE_EXPECT_TRUE(got_put);
     // Verify the put event contains node2's data
-    CASE_EXPECT_TRUE(!!(id_node_map.count(app2_id) > 0));
+    CASE_EXPECT_TRUE(id_node_map.count(app2_id) > 0);
     if (id_node_map.count(app2_id) > 0) {
       CASE_EXPECT_EQ(app2_id, id_node_map[app2_id]->get_discovery_info().id());
       CASE_EXPECT_EQ(app2_name, id_node_map[app2_id]->get_discovery_info().name());
@@ -1171,7 +1182,7 @@ CASE_TEST(atapp_etcd_module, topology_event_delete) {
   // Track app2-specific put event to avoid self-registration/refresh noise
   std::string app2_name;
   uint64_t app2_id = 0;
-  std::map<uint64_t, atapp::service_discovery_module::atapp_topology_info_ptr_t> topo_info_set;
+  std::unordered_map<uint64_t, atapp::service_discovery_module::atapp_topology_info_ptr_t> topo_info_set;
 
   auto handle = discovery_module1->add_on_topology_info_event(
       [&](atapp::service_discovery_module::topology_action_t action,
@@ -1211,7 +1222,7 @@ CASE_TEST(atapp_etcd_module, topology_event_delete) {
     bool got_put = run_apps_until(apps, [&topo_info_set, &app2_id]() { return topo_info_set.count(app2_id) > 0; });
     CASE_EXPECT_TRUE(got_put);
     // Verify the put event contains node2's data
-    CASE_EXPECT_TRUE(!!(topo_info_set.count(app2_id) > 0));
+    CASE_EXPECT_TRUE(topo_info_set.count(app2_id) > 0);
     if (topo_info_set.count(app2_id) > 0) {
       CASE_EXPECT_EQ(app2_id, topo_info_set[app2_id]->id());
       CASE_EXPECT_EQ(app2_name, topo_info_set[app2_id]->name());
@@ -1332,7 +1343,7 @@ CASE_TEST(atapp_etcd_module, multi_node_discovery_put_event) {
 
   // Register callback to track kPut events specifically for node2's ID
   uint64_t target_id = 0;
-  std::set<uint64_t> got_put_id;
+  std::unordered_set<uint64_t> got_put_id;
   int put_event_count = 0;
   auto handle = discovery_module1->add_on_node_discovery_event(
       [&got_put_id, &put_event_count](atapp::service_discovery_module::node_action_t action,
@@ -1429,8 +1440,9 @@ CASE_TEST(atapp_etcd_module, multi_node_discovery_delete_event) {
     std::vector<atframework::atapp::app *> apps = {&app1, &app2};
 
     // Wait for node1 to discover node2
-    bool found = run_apps_until(
-        apps, [&discovery_module1, app2_id]() { return !!discovery_module1->get_global_discovery().get_node_by_id(app2_id); });
+    bool found = run_apps_until(apps, [&discovery_module1, app2_id]() {
+      return !!discovery_module1->get_global_discovery().get_node_by_id(app2_id);
+    });
     CASE_EXPECT_TRUE(found);
     CASE_MSG_INFO() << "multi_node_discovery_delete: node1 found node2, id=" << app2_id << '\n';
 
@@ -1442,7 +1454,8 @@ CASE_TEST(atapp_etcd_module, multi_node_discovery_delete_event) {
   // Continue ticking app1 - node2 should disappear from global_discovery
   std::vector<atframework::atapp::app *> apps1 = {&app1};
   bool node2_gone = run_apps_until(
-      apps1, [&discovery_module1, app2_id]() { return !discovery_module1->get_global_discovery().get_node_by_id(app2_id); },
+      apps1,
+      [&discovery_module1, app2_id]() { return !discovery_module1->get_global_discovery().get_node_by_id(app2_id); },
       std::chrono::seconds(20));
 
   CASE_EXPECT_TRUE(node2_gone);
@@ -1519,3 +1532,216 @@ CASE_TEST(atapp_etcd_module, multi_node_custom_data) {
 
   CASE_MSG_INFO() << "multi_node_custom_data: local set/get API verified" << '\n';
 }
+
+// ============================================================
+// I.5.5: tick_keepalive_updates
+//   Regression guard: verifies that service_discovery_module::tick() calls
+//   update_keepalive_topology_value() (unconditionally) and
+//   update_keepalive_discovery_value() (when etcd is kRunning).
+//
+//   If these calls are removed from tick() during a refactor, this test will fail:
+//   - Topology keepalive actors will not receive runtime value updates
+//   - Discovery metadata changes (e.g. kind) will not propagate to etcd
+// ============================================================
+CASE_TEST(atapp_etcd_module, tick_keepalive_updates) {
+  if (!is_etcd_available()) {
+    CASE_MSG_INFO() << CASE_MSG_FCOLOR(YELLOW) << "etcd is not available at " << get_etcd_host() << ", skip this test"
+                    << '\n';
+    return;
+  }
+
+  std::string conf_path_base;
+  atfw::util::file_system::dirname(__FILE__, 0, conf_path_base);
+  std::string conf_path_1 = conf_path_base + "/atapp_test_etcd_module_node1.yaml";
+  std::string conf_path_2 = conf_path_base + "/atapp_test_etcd_module_node2.yaml";
+
+  if (!atfw::util::file_system::is_exist(conf_path_1.c_str()) ||
+      !atfw::util::file_system::is_exist(conf_path_2.c_str())) {
+    CASE_MSG_INFO() << CASE_MSG_FCOLOR(YELLOW) << "etcd node config not found, skip this test" << '\n';
+    return;
+  }
+
+  atframework::atapp::app app1;
+  atframework::atapp::app app2;
+  const char *args1[] = {"app1", "-c", conf_path_1.c_str(), "start"};
+  const char *args2[] = {"app2", "-c", conf_path_2.c_str(), "start"};
+  CASE_EXPECT_EQ(0, app1.init(nullptr, 4, args1, nullptr));
+  CASE_EXPECT_EQ(0, app2.init(nullptr, 4, args2, nullptr));
+
+  auto discovery1 = app1.get_service_discovery_module();
+  auto discovery2 = app2.get_service_discovery_module();
+  CASE_EXPECT_TRUE(!!discovery1);
+  CASE_EXPECT_TRUE(!!discovery2);
+  if (!discovery1 || !discovery2) {
+    return;
+  }
+
+  std::vector<atframework::atapp::app *> apps = {&app1, &app2};
+
+  // Phase 1: Wait for mutual discovery (initial registration via init_service_discovery_keepalives_watchers)
+  bool mutual_discovery = run_apps_until(apps, [&discovery1, &discovery2, &app1, &app2]() {
+    return !!discovery1->get_global_discovery().get_node_by_id(app2.get_id()) &&
+           !!discovery2->get_global_discovery().get_node_by_id(app1.get_id());
+  });
+  CASE_EXPECT_TRUE(mutual_discovery);
+
+  // Phase 2: Verify topology data was published via keepalive
+  // update_keepalive_topology_value() packs app topology and pushes it to etcd through keepalive actors.
+  // The initial call happens in init, but tick() must continue calling it for runtime topology updates.
+  {
+    const auto &topo_set = discovery2->get_topology_info_set();
+    auto topo_it = topo_set.find(app1.get_id());
+    CASE_EXPECT_TRUE(topo_it != topo_set.end());
+    if (topo_it != topo_set.end()) {
+      CASE_EXPECT_TRUE(!!topo_it->second.info);
+      if (topo_it->second.info) {
+        CASE_EXPECT_EQ(app1.get_id(), topo_it->second.info->id());
+        CASE_EXPECT_EQ(app1.get_app_name(), topo_it->second.info->name());
+        CASE_MSG_INFO() << "tick_keepalive_updates: topology id=" << topo_it->second.info->id()
+                        << " name=" << topo_it->second.info->name() << '\n';
+      }
+    }
+  }
+
+  // Phase 3: Change app1's kind to trigger a discovery metadata update
+  // set_kind() internally calls set_maybe_update_keepalive_discovery_metadata(),
+  // setting the flag that update_keepalive_discovery_value() must process in tick().
+  // If update_keepalive_discovery_value() is removed from tick(), the new kind
+  // will never be pushed to etcd and app2 will never see the change.
+  CASE_EXPECT_NE(std::string("test_kind_tick_verify"), app1.get_metadata().kind());
+  app1.set_kind("test_kind_tick_verify");
+
+  // Phase 4: Tick and wait for the discovery metadata change to propagate
+  bool kind_updated = run_apps_until(apps, [&discovery2, &app1]() {
+    auto node = discovery2->get_global_discovery().get_node_by_id(app1.get_id());
+    if (!node) {
+      return false;
+    }
+    return node->get_discovery_info().metadata().kind() == "test_kind_tick_verify";
+  });
+  CASE_EXPECT_TRUE(kind_updated);
+
+  CASE_MSG_INFO() << "tick_keepalive_updates: mutual_discovery=" << (mutual_discovery ? "true" : "false")
+                  << " kind_updated=" << (kind_updated ? "true" : "false") << '\n';
+}
+
+// ============================================================
+// I.5.6: multi_context_snapshot_isolation
+// 多context下节点迁移
+// app1 app2 首先在同一etcd path内
+// app2 下线后在另一节点上线
+// 验证是否可以看见上线的节点，并且下线的节点被删除
+// ============================================================
+CASE_TEST(atapp_etcd_module, multi_context_snapshot_isolation) {
+  if (!is_etcd_available()) {
+    CASE_MSG_INFO() << CASE_MSG_FCOLOR(YELLOW) << "etcd is not available at " << get_etcd_host() << ", skip this test"
+                    << '\n';
+    return;
+  }
+
+  std::string conf_path_base;
+  atfw::util::file_system::dirname(__FILE__, 0, conf_path_base);
+  std::string conf_path_1 = conf_path_base + "/atapp_test_etcd_module_node1.yaml";
+  std::string conf_path_2 = conf_path_base + "/atapp_test_etcd_module_node2.yaml";
+  std::string conf_path_3 = conf_path_base + "/atapp_test_etcd_module_multi_context_node2.yaml";
+
+  if (!atfw::util::file_system::is_exist(conf_path_1.c_str()) ||
+      !atfw::util::file_system::is_exist(conf_path_2.c_str()) ||
+      !atfw::util::file_system::is_exist(conf_path_3.c_str())) {
+    CASE_MSG_INFO() << CASE_MSG_FCOLOR(YELLOW) << "etcd node config not found, skip this test" << '\n';
+    return;
+  }
+
+  atframework::atapp::app app1;
+  const char *args1[] = {"app1", "-c", conf_path_1.c_str(), "start"};
+  CASE_EXPECT_EQ(0, app1.init(nullptr, 4, args1, nullptr));
+
+  auto discovery1 = app1.get_service_discovery_module();
+  CASE_EXPECT_TRUE(!!discovery1);
+  if (!discovery1) {
+    return;
+  }
+
+  uint64_t app2_id = 0;
+  {
+    atframework::atapp::app app2;
+    const char *args2[] = {"app2", "-c", conf_path_2.c_str(), "start"};
+    CASE_EXPECT_EQ(0, app2.init(nullptr, 4, args2, nullptr));
+    auto discovery2 = app2.get_service_discovery_module();
+    CASE_EXPECT_TRUE(!!discovery2);
+    if (!discovery2) {
+      return;
+    }
+
+    std::vector<atframework::atapp::app *> apps = {&app1, &app2};
+
+    // Phase 1: Wait for mutual discovery via the default context
+    bool mutual_discovery = run_apps_until(apps, [&discovery1, &discovery2, &app1, &app2]() {
+      return discovery1->get_global_discovery().get_node_by_id(app2.get_id()) &&
+             discovery2->get_global_discovery().get_node_by_id(app1.get_id());
+    });
+    CASE_EXPECT_TRUE(mutual_discovery);
+    if (!mutual_discovery) {
+      return;
+    }
+    app2_id = app2.get_id();
+  }
+
+  std::vector<atframework::atapp::app *> apps = {&app1};
+  // Phase 2: 下线节点
+  run_apps_until(apps, [&discovery1, app2_id]() {
+    if (!discovery1->get_global_discovery().get_node_by_id(app2_id)) {
+      return true;
+    }
+    return false;
+  });
+  CASE_EXPECT_TRUE(!discovery1->get_global_discovery().get_node_by_id(app2_id));
+  if (discovery1->get_global_discovery().get_node_by_id(app2_id) != nullptr) {
+    return;
+  }
+
+  // Phase 3: 上线节点到新的context
+  atframework::atapp::app app3;
+  const char *args3[] = {"app3", "-c", conf_path_3.c_str(), "start"};
+  CASE_EXPECT_EQ(0, app3.init(nullptr, 4, args3, nullptr));
+  auto discovery3 = app3.get_service_discovery_module();
+  CASE_EXPECT_TRUE(!!discovery3);
+  if (!discovery3) {
+    return;
+  }
+
+  // Phase 4: app1接入新节点 context
+  auto service_discovery_context =
+      std::make_shared<atframework::atapp::service_discovery_module::service_discovery_cluster_context>();
+  int ret = service_discovery_context->init(app1, discovery3->get_configure(), nullptr);
+  CASE_EXPECT_TRUE(ret == 0);
+  if (ret != 0) {
+    return;
+  }
+
+  ret = discovery1->init_service_discovery_keepalives_watchers(service_discovery_context);
+  CASE_EXPECT_TRUE(ret == 0);
+  if (ret != 0) {
+    return;
+  }
+  bool success = service_discovery_context->check_keepalive_actor_start_success();
+  CASE_EXPECT_TRUE(success);
+  if (!success) {
+    return;
+  }
+
+  // Phase 5: 等待发现app3
+  apps = {&app1, &app3};
+  bool mutual_discovery = run_apps_until(apps, [&discovery1, &discovery3, &app1, &app3]() {
+    return !!discovery1->get_global_discovery().get_node_by_id(app3.get_id()) &&
+           !!discovery3->get_global_discovery().get_node_by_id(app1.get_id());
+  });
+  CASE_EXPECT_TRUE(mutual_discovery);
+  if (!mutual_discovery) {
+    return;
+  }
+  CASE_EXPECT_TRUE(!!discovery1->get_global_discovery().get_node_by_id(app3.get_id()));
+  CASE_EXPECT_TRUE(!!discovery1->get_global_discovery().get_node_by_id(app1.get_id()));
+  CASE_EXPECT_TRUE(!!discovery3->get_global_discovery().get_node_by_id(app1.get_id()));
+  CASE_EXPECT_TRUE(!!discovery3->get_global_discovery().get_node_by_id(app3.get_id()));
+}
diff --git a/test/case/atapp_etcd_module_unit_test.cpp b/test/case/atapp_etcd_module_unit_test.cpp
index daf8756..eb5969f 100644
--- a/test/case/atapp_etcd_module_unit_test.cpp
+++ b/test/case/atapp_etcd_module_unit_test.cpp
@@ -386,7 +386,7 @@ CASE_TEST(atapp_etcd_module_unit, version_update_by_reference) {
   std::unordered_map<uint64_t, atapp::service_discovery_module::topology_storage_t> topology_map;
 
   atapp::service_discovery_module::topology_storage_t initial;
-  initial.context_ptr = 0;
+  initial.context_addr = 0;
   initial.version.create_revision = 1;
   initial.version.modify_revision = 1;
   initial.version.version = 1;
@@ -651,7 +651,7 @@ CASE_TEST(atapp_etcd_module_unit, topology_map_insert_and_upgrade) {
   info->set_upstream_id(1);
 
   atapp::service_discovery_module::topology_storage_t entry;
-  entry.context_ptr = 0;
+  entry.context_addr = 0;
   entry.info = info;
   entry.version.create_revision = 1;
   entry.version.modify_revision = 1;
@@ -686,7 +686,7 @@ CASE_TEST(atapp_etcd_module_unit, topology_map_multiple_entries) {
     atapp::service_discovery_module::topology_storage_t entry;
     entry.info = atfw::util::memory::make_strong_rc<atapp::protocol::atapp_topology_info>();
     entry.info->set_id(i);
-    entry.context_ptr = 0;
+    entry.context_addr = 0;
     entry.version.create_revision = static_cast<int64_t>(i);
     entry.version.modify_revision = static_cast<int64_t>(i);
     entry.version.version = 1;
diff --git a/test/case/atapp_test_etcd_module_multi_context_node2.yaml b/test/case/atapp_test_etcd_module_multi_context_node2.yaml
new file mode 100644
index 0000000..750c4f7
--- /dev/null
+++ b/test/case/atapp_test_etcd_module_multi_context_node2.yaml
@@ -0,0 +1,78 @@
+# Copyright 2026 atframework
+atapp:
+  id: 0x00000802
+  id_mask: 8.8.8.8
+  name: "etcd-test-node2"
+  type_id: 8
+  type_name: "etcd-multi-test"
+
+  bus:
+    listen: "ipv4://127.0.0.1:22302"
+    proxy: ""
+    backlog: 256
+    access_token_max_number: 5
+    overwrite_listen_path: false
+    topology:
+      rule:
+        allow_direct_connection: true
+        require_same_upstream: false
+    first_idle_timeout: 10s
+    ping_interval: 60s
+    retry_interval: 3s
+    fault_tolerant: 3
+    message_size: 64KB
+    receive_buffer_size: 1MB
+    send_buffer_size: 1MB
+    send_buffer_number: 0
+  timer:
+    tick_interval: 8ms
+    stop_timeout: 3s
+    stop_interval: 256ms
+  etcd:
+    enable: true
+    hosts:
+      - "${ATAPP_UNIT_TEST_ETCD_HOST:-http://127.0.0.1:12379}"
+    path: "/atapp/unit-test/atapp_etcd_module/libatapp_extra_ctx"
+    init:
+      timeout: "15s"
+      tick_interval: "64ms"
+    keepalive:
+      timeout: "16s"
+      ttl: "5s"
+      retry_interval: "3s"
+    request:
+      timeout: "5s"
+      initialization_timeout: "3s"
+    watcher:
+      retry_interval: "3s"
+      request_timeout: "3600s"
+      get_request_timeout: "180s"
+
+  log:
+    level: debug
+    category:
+      - name: default
+        prefix: "[Log %L][%F %T.%f][%s:%n(%C)]: "
+        stacktrace:
+          min: disable
+          max: disable
+        sink:
+          - type: file
+            level:
+              min: fatal
+              max: debug
+            rotate:
+              number: 10
+              size: 10485760
+            file: "../log/etcd-test-node2.%N.log"
+            writing_alias: "../log/etcd-test-node2.log"
+            auto_flush: info
+            flush_interval: 1s
+          - type: stderr
+            level:
+              min: fatal
+              max: warning
+          - type: stdout
+            level:
+              min: fatal
+              max: debug

From 6a5653a2ad7f75fa9b364154e6d5e2bd8d9e4ad6 Mon Sep 17 00:00:00 2001
From: yousongyang <yousongyang0105@gmail.com>
Date: Wed, 10 Jun 2026 14:51:25 +0800
Subject: [PATCH 03/12] =?UTF-8?q?ETCD=20=E4=B8=8E=20Discovery=20=E5=88=86?=
 =?UTF-8?q?=E7=A6=BB=20CR?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 include/atframe/modules/etcd_module.h         |  1 +
 .../modules/service_discovery_module.h        |  4 ++-
 src/atframe/modules/etcd_module.cpp           |  4 ++-
 .../modules/service_discovery_module.cpp      | 31 ++++++++++++++++---
 test/case/atapp_etcd_module_test.cpp          |  7 ++++-
 5 files changed, 40 insertions(+), 7 deletions(-)

diff --git a/include/atframe/modules/etcd_module.h b/include/atframe/modules/etcd_module.h
index 30fbdd9..d1fcea2 100644
--- a/include/atframe/modules/etcd_module.h
+++ b/include/atframe/modules/etcd_module.h
@@ -56,6 +56,7 @@ class etcd_module {
                          const atapp::protocol::atapp_log *ATFW_UTIL_MACRO_NULLABLE log_conf = nullptr);
 
   bool enable_;
+  bool init_;
   atfw::util::network::http_request::ptr_t cleanup_request_;
 
   atframework::atapp::app *ATFW_UTIL_MACRO_NULLABLE atapp_;
diff --git a/include/atframe/modules/service_discovery_module.h b/include/atframe/modules/service_discovery_module.h
index 36fcf08..03f51a3 100644
--- a/include/atframe/modules/service_discovery_module.h
+++ b/include/atframe/modules/service_discovery_module.h
@@ -183,7 +183,9 @@ class service_discovery_module : public ::atframework::atapp::module_impl {
   LIBATAPP_MACRO_API static std::string get_topology_watcher_path(atframework::atapp::app &app,
                                                                   const std::string &path);
 
-  LIBATAPP_MACRO_API int init_service_discovery_keepalives_watchers(
+  LIBATAPP_MACRO_API int init_service_discovery_keepalives(
+      ::atfw::util::nostd::nonnull<std::shared_ptr<service_discovery_cluster_context>> context);
+  LIBATAPP_MACRO_API int init_service_discovery_watchers(
       ::atfw::util::nostd::nonnull<std::shared_ptr<service_discovery_cluster_context>> context);
 
   LIBATAPP_MACRO_API static int init_discovery_watcher_by_id(
diff --git a/src/atframe/modules/etcd_module.cpp b/src/atframe/modules/etcd_module.cpp
index eedbdc9..cd5adf5 100644
--- a/src/atframe/modules/etcd_module.cpp
+++ b/src/atframe/modules/etcd_module.cpp
@@ -81,6 +81,7 @@ static void init_timer_closed_callback(uv_handle_t *handle) {
 
 LIBATAPP_MACRO_API etcd_module::etcd_module()
     : enable_(false),
+      init_(false),
       atapp_(nullptr),
       tick_interval_(std::chrono::duration_cast<std::chrono::system_clock::duration>(std::chrono::milliseconds(128))) {
   tick_next_timepoint_ = app::get_sys_now();
@@ -90,6 +91,7 @@ LIBATAPP_MACRO_API etcd_module::~etcd_module() { reset(); }
 
 LIBATAPP_MACRO_API int etcd_module::init(atframework::atapp::app &app, const atapp::protocol::atapp_etcd &conf,
                                          const atapp::protocol::atapp_log *ATFW_UTIL_MACRO_NULLABLE log_conf) {
+  init_ = true;
   atapp_ = &app;
   load_cluster_conf(conf, log_conf);
   if (cluster_.get_conf_hosts().empty()) {
@@ -106,7 +108,7 @@ LIBATAPP_MACRO_API int etcd_module::reload(const atapp::protocol::atapp_etcd &co
   if (atapp_ == nullptr) {
     return 0;
   }
-  if (is_etcd_enabled()) {
+  if (!init_ || is_etcd_enabled()) {
     load_cluster_conf(conf, log_conf);
   }
   return 0;
diff --git a/src/atframe/modules/service_discovery_module.cpp b/src/atframe/modules/service_discovery_module.cpp
index 9808e94..f72bc89 100644
--- a/src/atframe/modules/service_discovery_module.cpp
+++ b/src/atframe/modules/service_discovery_module.cpp
@@ -231,7 +231,13 @@ LIBATAPP_MACRO_API int service_discovery_module::init() {
     return 0;
   }
 
-  ret = init_service_discovery_keepalives_watchers(cluster_context_);
+  ret = init_service_discovery_keepalives(cluster_context_);
+  if (ret < 0) {
+    stop();
+    return ret;
+  }
+
+  ret = init_service_discovery_watchers(cluster_context_);
   if (ret < 0) {
     stop();
     return ret;
@@ -287,7 +293,13 @@ LIBATAPP_MACRO_API void service_discovery_module::enable_discovery() {
     return;
   }
 
-  int ret = init_service_discovery_keepalives_watchers(cluster_context_);
+  int ret = init_service_discovery_keepalives(cluster_context_);
+  if (ret < 0) {
+    discovery_enabled_ = false;
+    cluster_context_->reset_internal_watchers_and_keepalives();
+  }
+
+  ret = init_service_discovery_watchers(cluster_context_);
   if (ret < 0) {
     discovery_enabled_ = false;
     cluster_context_->reset_internal_watchers_and_keepalives();
@@ -379,7 +391,7 @@ void service_discovery_module::update_keepalive_discovery_value() {
   }
 }
 
-LIBATAPP_MACRO_API int service_discovery_module::init_service_discovery_keepalives_watchers(
+LIBATAPP_MACRO_API int service_discovery_module::init_service_discovery_keepalives(
     ::atfw::util::nostd::nonnull<std::shared_ptr<service_discovery_cluster_context>> context) {
   // 先刷新topology数据，后刷新discovery数据，以保证策略路由变化时已获取到最新的topology信息
   update_keepalive_topology_value();
@@ -400,7 +412,18 @@ LIBATAPP_MACRO_API int service_discovery_module::init_service_discovery_keepaliv
     return ret;
   }
 
-  ret = add_topology_watcher_callback(app, context, nullptr);
+  return 0;
+}
+
+LIBATAPP_MACRO_API int service_discovery_module::init_service_discovery_watchers(
+    ::atfw::util::nostd::nonnull<std::shared_ptr<service_discovery_cluster_context>> context) {
+  // 先刷新topology数据，后刷新discovery数据，以保证策略路由变化时已获取到最新的topology信息
+  update_keepalive_topology_value();
+  update_keepalive_discovery_value();
+
+  atframework::atapp::app &app = *get_app();
+
+  int ret = add_topology_watcher_callback(app, context, nullptr);
   if (ret < 0) {
     return ret;
   }
diff --git a/test/case/atapp_etcd_module_test.cpp b/test/case/atapp_etcd_module_test.cpp
index b236987..124357d 100644
--- a/test/case/atapp_etcd_module_test.cpp
+++ b/test/case/atapp_etcd_module_test.cpp
@@ -1719,7 +1719,12 @@ CASE_TEST(atapp_etcd_module, multi_context_snapshot_isolation) {
     return;
   }
 
-  ret = discovery1->init_service_discovery_keepalives_watchers(service_discovery_context);
+  ret = discovery1->init_service_discovery_keepalives(service_discovery_context);
+  CASE_EXPECT_TRUE(ret == 0);
+  if (ret != 0) {
+    return;
+  }
+  ret = discovery1->init_service_discovery_watchers(service_discovery_context);
   CASE_EXPECT_TRUE(ret == 0);
   if (ret != 0) {
     return;

From e2dd9a69a1d4b0edd4a5340f64fdc91f19dd8eba Mon Sep 17 00:00:00 2001
From: yousongyang <yousongyang0105@gmail.com>
Date: Wed, 10 Jun 2026 17:58:32 +0800
Subject: [PATCH 04/12] =?UTF-8?q?ETCD=20=E4=B8=8E=20Discovery=20=E5=88=86?=
 =?UTF-8?q?=E7=A6=BB=20=E8=A1=A5=E5=85=85=E6=B5=8B=E8=AF=95=E7=94=A8?=
 =?UTF-8?q?=E4=BE=8B=20=E6=94=AF=E6=8C=81=E5=A4=9A=E9=85=8D=E7=BD=AE?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 include/atframe/atapp_conf.proto              |   9 +-
 .../modules/service_discovery_module.h        |  36 ++-
 src/atframe/atapp.cpp                         |  18 +-
 src/atframe/modules/etcd_module.cpp           |   2 +
 .../modules/service_discovery_module.cpp      | 252 ++++++++++-----
 test/case/atapp_etcd_module_test.cpp          | 300 +++++++++++++++++-
 ...tapp_test_etcd_module_ext_disc_node1a.yaml | 105 ++++++
 ...tapp_test_etcd_module_ext_disc_node1b.yaml | 105 ++++++
 ...tapp_test_etcd_module_ext_disc_node2a.yaml | 105 ++++++
 ...tapp_test_etcd_module_ext_disc_node2b.yaml | 105 ++++++
 ..._test_etcd_module_multi_context_node3.yaml |  78 +++++
 11 files changed, 996 insertions(+), 119 deletions(-)
 create mode 100644 test/case/atapp_test_etcd_module_ext_disc_node1a.yaml
 create mode 100644 test/case/atapp_test_etcd_module_ext_disc_node1b.yaml
 create mode 100644 test/case/atapp_test_etcd_module_ext_disc_node2a.yaml
 create mode 100644 test/case/atapp_test_etcd_module_ext_disc_node2b.yaml
 create mode 100644 test/case/atapp_test_etcd_module_multi_context_node3.yaml

diff --git a/include/atframe/atapp_conf.proto b/include/atframe/atapp_conf.proto
index 4579c1d..1a426e1 100644
--- a/include/atframe/atapp_conf.proto
+++ b/include/atframe/atapp_conf.proto
@@ -408,9 +408,10 @@ message atapp_etcd_cluster {
 }
 
 message atapp_etcd_keepalive {
-  google.protobuf.Duration timeout = 1 [(atapp.protocol.CONFIGURE) = { default_value: "31s" }];
-  google.protobuf.Duration ttl = 2 [(atapp.protocol.CONFIGURE) = { default_value: "10s" }];
-  google.protobuf.Duration retry_interval = 3 [(atapp.protocol.CONFIGURE) = { default_value: "3s" }];
+  bool enabled = 1 [(atapp.protocol.CONFIGURE) = { default_value: "true" }];
+  google.protobuf.Duration timeout = 101 [(atapp.protocol.CONFIGURE) = { default_value: "31s" }];
+  google.protobuf.Duration ttl = 102 [(atapp.protocol.CONFIGURE) = { default_value: "10s" }];
+  google.protobuf.Duration retry_interval = 103 [(atapp.protocol.CONFIGURE) = { default_value: "3s" }];
 }
 
 message atapp_etcd_request {
@@ -428,6 +429,7 @@ message atapp_etcd_init {
 }
 
 message atapp_etcd_watcher {
+  bool enabled = 1 [(atapp.protocol.CONFIGURE) = { default_value: "true" }];
   google.protobuf.Duration retry_interval = 101 [(atapp.protocol.CONFIGURE) = { default_value: "15s" }];
   google.protobuf.Duration request_timeout = 102 [(atapp.protocol.CONFIGURE) = { default_value: "30m" }];
   google.protobuf.Duration get_request_timeout = 103 [(atapp.protocol.CONFIGURE) = { default_value: "3m" }];
@@ -593,6 +595,7 @@ message atapp_configure {
   atbus_configure bus = 301;
 
   atapp_etcd etcd = 401;
+  repeated atapp_etcd external_discovery = 402;
 
   atapp_worker_pool worker_pool = 501;
 }
diff --git a/include/atframe/modules/service_discovery_module.h b/include/atframe/modules/service_discovery_module.h
index 03f51a3..d339763 100644
--- a/include/atframe/modules/service_discovery_module.h
+++ b/include/atframe/modules/service_discovery_module.h
@@ -183,41 +183,45 @@ class service_discovery_module : public ::atframework::atapp::module_impl {
   LIBATAPP_MACRO_API static std::string get_topology_watcher_path(atframework::atapp::app &app,
                                                                   const std::string &path);
 
+  LIBATAPP_MACRO_API void reset_context_internal_watchers_and_keepalives();
   LIBATAPP_MACRO_API int init_service_discovery_keepalives(
-      ::atfw::util::nostd::nonnull<std::shared_ptr<service_discovery_cluster_context>> context);
+      const ::atfw::util::nostd::nonnull<std::shared_ptr<service_discovery_cluster_context>> &context);
   LIBATAPP_MACRO_API int init_service_discovery_watchers(
-      ::atfw::util::nostd::nonnull<std::shared_ptr<service_discovery_cluster_context>> context);
+      const ::atfw::util::nostd::nonnull<std::shared_ptr<service_discovery_cluster_context>> &context);
 
   LIBATAPP_MACRO_API static int init_discovery_watcher_by_id(
       atframework::atapp::app &app,
-      ::atfw::util::nostd::nonnull<std::shared_ptr<service_discovery_cluster_context>> context);
+      const ::atfw::util::nostd::nonnull<std::shared_ptr<service_discovery_cluster_context>> &context);
   LIBATAPP_MACRO_API static int init_discovery_watcher_by_name(
       atframework::atapp::app &app,
-      ::atfw::util::nostd::nonnull<std::shared_ptr<service_discovery_cluster_context>> context);
+      const ::atfw::util::nostd::nonnull<std::shared_ptr<service_discovery_cluster_context>> &context);
   LIBATAPP_MACRO_API static int init_topology_watcher(
       atframework::atapp::app &app,
-      ::atfw::util::nostd::nonnull<std::shared_ptr<service_discovery_cluster_context>> context);
+      const ::atfw::util::nostd::nonnull<std::shared_ptr<service_discovery_cluster_context>> &context);
   LIBATAPP_MACRO_API static int init_discovery_keepalive_by_id(
       atframework::atapp::app &app,
-      ::atfw::util::nostd::nonnull<std::shared_ptr<service_discovery_cluster_context>> context, std::string &value);
+      const ::atfw::util::nostd::nonnull<std::shared_ptr<service_discovery_cluster_context>> &context,
+      std::string &value);
   LIBATAPP_MACRO_API static int init_discovery_keepalive_by_name(
       atframework::atapp::app &app,
-      ::atfw::util::nostd::nonnull<std::shared_ptr<service_discovery_cluster_context>> context, std::string &value);
+      const ::atfw::util::nostd::nonnull<std::shared_ptr<service_discovery_cluster_context>> &context,
+      std::string &value);
   LIBATAPP_MACRO_API static int init_topology_keepalive(
       atframework::atapp::app &app,
-      ::atfw::util::nostd::nonnull<std::shared_ptr<service_discovery_cluster_context>> context, std::string &value);
+      const ::atfw::util::nostd::nonnull<std::shared_ptr<service_discovery_cluster_context>> &context,
+      std::string &value);
 
   LIBATAPP_MACRO_API static int add_discovery_watcher_by_id_callback(
       atframework::atapp::app &app,
-      ::atfw::util::nostd::nonnull<std::shared_ptr<service_discovery_cluster_context>> context,
+      const ::atfw::util::nostd::nonnull<std::shared_ptr<service_discovery_cluster_context>> &context,
       const discovery_watcher_list_callback_t &fn);
   LIBATAPP_MACRO_API static int add_discovery_watcher_by_name_callback(
       atframework::atapp::app &app,
-      ::atfw::util::nostd::nonnull<std::shared_ptr<service_discovery_cluster_context>> context,
+      const ::atfw::util::nostd::nonnull<std::shared_ptr<service_discovery_cluster_context>> &context,
       const discovery_watcher_list_callback_t &fn);
   LIBATAPP_MACRO_API static int add_topology_watcher_callback(
       atframework::atapp::app &app,
-      ::atfw::util::nostd::nonnull<std::shared_ptr<service_discovery_cluster_context>> context,
+      const ::atfw::util::nostd::nonnull<std::shared_ptr<service_discovery_cluster_context>> &context,
       const topology_watcher_list_callback_t &fn);
 
   LIBATAPP_MACRO_API const ::atframework::atapp::etcd_cluster &get_raw_etcd_ctx() const;
@@ -233,14 +237,14 @@ class service_discovery_module : public ::atframework::atapp::module_impl {
 
   LIBATAPP_MACRO_API static atapp::etcd_keepalive::ptr_t add_keepalive_actor(
       atframework::atapp::app &app,
-      ::atfw::util::nostd::nonnull<std::shared_ptr<service_discovery_cluster_context>> context, std::string &val,
+      const ::atfw::util::nostd::nonnull<std::shared_ptr<service_discovery_cluster_context>> &context, std::string &val,
       const std::string &node_path);
   LIBATAPP_MACRO_API atapp::etcd_keepalive::ptr_t add_keepalive_actor(atframework::atapp::app &app, std::string &val,
                                                                       const std::string &node_path);
 
   LIBATAPP_MACRO_API static bool remove_keepalive_actor(
       atframework::atapp::app &app,
-      ::atfw::util::nostd::nonnull<std::shared_ptr<service_discovery_cluster_context>> context,
+      const ::atfw::util::nostd::nonnull<std::shared_ptr<service_discovery_cluster_context>> &context,
       const atapp::etcd_keepalive::ptr_t &keepalive);
   LIBATAPP_MACRO_API bool remove_keepalive_actor(atframework::atapp::app &app,
                                                  const atapp::etcd_keepalive::ptr_t &keepalive);
@@ -276,9 +280,9 @@ class service_discovery_module : public ::atframework::atapp::module_impl {
   LIBATAPP_MACRO_API void remove_on_topology_snapshot_loaded(topology_snapshot_event_callback_handle_t &handle);
 
   LIBATAPP_MACRO_API etcd_watcher::watch_event_fn_t_ptr create_discovery_watcher_callback_list_wrapper(
-      ::atfw::util::nostd::nonnull<std::shared_ptr<service_discovery_cluster_context>> context);
+      const ::atfw::util::nostd::nonnull<std::shared_ptr<service_discovery_cluster_context>> &context);
   LIBATAPP_MACRO_API etcd_watcher::watch_event_fn_t_ptr create_topology_watcher_callback_list_wrapper(
-      ::atfw::util::nostd::nonnull<std::shared_ptr<service_discovery_cluster_context>> context);
+      const ::atfw::util::nostd::nonnull<std::shared_ptr<service_discovery_cluster_context>> &context);
 
  private:
   static bool unpack(node_info_t &out, const std::string &path, const std::string &json, bool reset_data);
@@ -297,6 +301,8 @@ class service_discovery_module : public ::atframework::atapp::module_impl {
  private:
   bool discovery_enabled_;
   ::atfw::util::nostd::nonnull<std::shared_ptr<service_discovery_cluster_context>> cluster_context_;
+  std::list<::atfw::util::nostd::nonnull<std::shared_ptr<service_discovery_cluster_context>>>
+      external_cluster_contexts_;
 
   bool maybe_update_internal_keepalive_topology_value_;
   bool maybe_update_internal_keepalive_discovery_value_;
diff --git a/src/atframe/atapp.cpp b/src/atframe/atapp.cpp
index 1d63a45..773fe74 100644
--- a/src/atframe/atapp.cpp
+++ b/src/atframe/atapp.cpp
@@ -39,6 +39,9 @@
 #include <iomanip>
 #include <iostream>
 #include <sstream>
+#include <unordered_set>
+#include <utility>
+#include <list>
 #if !(defined(ATFRAMEWORK_UTILS_THREAD_TLS_USE_PTHREAD) && ATFRAMEWORK_UTILS_THREAD_TLS_USE_PTHREAD) && \
     __cplusplus >= 201103L
 #  include <mutex>
@@ -332,18 +335,23 @@ struct LIBATAPP_MACRO_API curl_multi_guard_type {
       curl_global_cleanup();
     }
   }
+  curl_multi_guard_type(const curl_multi_guard_type &) = delete;
+  curl_multi_guard_type &operator=(const curl_multi_guard_type &) = delete;
   int init_result;
 };
 
 namespace {
 static std::shared_ptr<curl_multi_guard_type> create_curl_multi_guard() {
-  std::shared_ptr<curl_multi_guard_type> guard = std::make_shared<curl_multi_guard_type>();
-  if (guard->init_result != CURLE_OK) {
-    return nullptr;
-  }
+  static std::shared_ptr<curl_multi_guard_type> guard = []() -> std::shared_ptr<curl_multi_guard_type> {
+    auto g = std::make_shared<curl_multi_guard_type>();
+    if (g->init_result != 0) {
+      return nullptr;
+    }
+    return g;
+  }();
   return guard;
 }
-}
+}  // namespace
 
 LIBATAPP_MACRO_API app::message_t::message_t() : type(0), message_sequence(0), metadata(nullptr) {}
 LIBATAPP_MACRO_API app::message_t::~message_t() {}
diff --git a/src/atframe/modules/etcd_module.cpp b/src/atframe/modules/etcd_module.cpp
index cd5adf5..106ad4a 100644
--- a/src/atframe/modules/etcd_module.cpp
+++ b/src/atframe/modules/etcd_module.cpp
@@ -30,6 +30,7 @@
 #include <unordered_map>
 #include <utility>
 #include <vector>
+#include <list>
 
 #if defined(max)
 #  undef max
@@ -108,6 +109,7 @@ LIBATAPP_MACRO_API int etcd_module::reload(const atapp::protocol::atapp_etcd &co
   if (atapp_ == nullptr) {
     return 0;
   }
+  // FIXME 现在不支持动态开关 etcd 功能
   if (!init_ || is_etcd_enabled()) {
     load_cluster_conf(conf, log_conf);
   }
diff --git a/src/atframe/modules/service_discovery_module.cpp b/src/atframe/modules/service_discovery_module.cpp
index f72bc89..4dcbc5f 100644
--- a/src/atframe/modules/service_discovery_module.cpp
+++ b/src/atframe/modules/service_discovery_module.cpp
@@ -31,6 +31,7 @@
 #include <unordered_map>
 #include <utility>
 #include <vector>
+#include <list>
 
 #if defined(max)
 #  undef max
@@ -127,7 +128,7 @@ static bool topology_update_version(service_discovery_module::topology_storage_t
 
 struct ATFW_UTIL_SYMBOL_LOCAL service_discovery_module::topology_watcher_callback_list_wrapper_t {
   service_discovery_module *ATFW_UTIL_MACRO_NONNULL mod;
-  ::atfw::util::nostd::nonnull<std::shared_ptr<service_discovery_cluster_context>> ctx;
+  std::weak_ptr<service_discovery_cluster_context> ctx;
 
   std::recursive_mutex *ATFW_UTIL_MACRO_NULLABLE callback_lock;
   std::list<topology_watcher_list_callback_t> *ATFW_UTIL_MACRO_NULLABLE callbacks;
@@ -135,10 +136,11 @@ struct ATFW_UTIL_SYMBOL_LOCAL service_discovery_module::topology_watcher_callbac
   bool has_insert_snapshot_index;
 
   topology_watcher_callback_list_wrapper_t(
-      service_discovery_module &m, ::atfw::util::nostd::nonnull<std::shared_ptr<service_discovery_cluster_context>> c,
-      int64_t index);
+      service_discovery_module &m,
+      const ::atfw::util::nostd::nonnull<std::shared_ptr<service_discovery_cluster_context>> &c, int64_t index);
   topology_watcher_callback_list_wrapper_t(
-      service_discovery_module &m, ::atfw::util::nostd::nonnull<std::shared_ptr<service_discovery_cluster_context>> c,
+      service_discovery_module &m,
+      const ::atfw::util::nostd::nonnull<std::shared_ptr<service_discovery_cluster_context>> &c,
       std::recursive_mutex &lock, std::list<topology_watcher_list_callback_t> &cbks, int64_t index);
   ~topology_watcher_callback_list_wrapper_t();
   void operator()(const ::atframework::atapp::etcd_response_header &header,
@@ -147,7 +149,7 @@ struct ATFW_UTIL_SYMBOL_LOCAL service_discovery_module::topology_watcher_callbac
 
 struct ATFW_UTIL_SYMBOL_LOCAL service_discovery_module::discovery_watcher_callback_list_wrapper_t {
   service_discovery_module *ATFW_UTIL_MACRO_NONNULL mod;
-  ::atfw::util::nostd::nonnull<std::shared_ptr<service_discovery_cluster_context>> ctx;
+  std::weak_ptr<service_discovery_cluster_context> ctx;
 
   std::recursive_mutex *ATFW_UTIL_MACRO_NULLABLE callback_lock;
   std::list<discovery_watcher_list_callback_t> *ATFW_UTIL_MACRO_NULLABLE callbacks;
@@ -155,10 +157,11 @@ struct ATFW_UTIL_SYMBOL_LOCAL service_discovery_module::discovery_watcher_callba
   bool has_insert_snapshot_index;
 
   discovery_watcher_callback_list_wrapper_t(
-      service_discovery_module &m, ::atfw::util::nostd::nonnull<std::shared_ptr<service_discovery_cluster_context>> c,
-      int64_t index);
+      service_discovery_module &m,
+      const ::atfw::util::nostd::nonnull<std::shared_ptr<service_discovery_cluster_context>> &c, int64_t index);
   discovery_watcher_callback_list_wrapper_t(
-      service_discovery_module &m, ::atfw::util::nostd::nonnull<std::shared_ptr<service_discovery_cluster_context>> c,
+      service_discovery_module &m,
+      const ::atfw::util::nostd::nonnull<std::shared_ptr<service_discovery_cluster_context>> &c,
       std::recursive_mutex &lock, std::list<discovery_watcher_list_callback_t> &cbks, int64_t index);
   ~discovery_watcher_callback_list_wrapper_t();
   void operator()(const ::atframework::atapp::etcd_response_header &header,
@@ -227,6 +230,18 @@ LIBATAPP_MACRO_API int service_discovery_module::init() {
     return ret;
   }
 
+  for (const auto &config : get_app()->get_origin_configure().external_discovery()) {
+    if (!config.enable()) {
+      continue;
+    }
+    auto external_cluster_context = std::make_shared<service_discovery_cluster_context>();
+    ret = external_cluster_context->init(*get_app(), config, nullptr);
+    if (ret < 0) {
+      return ret;
+    }
+    external_cluster_contexts_.push_back(std::move(external_cluster_context));
+  }
+
   if (!is_discovery_enabled()) {
     return 0;
   }
@@ -248,6 +263,25 @@ LIBATAPP_MACRO_API int service_discovery_module::init() {
     return -1;
   }
 
+  for (const auto &external_cluster_context : external_cluster_contexts_) {
+    ret = init_service_discovery_keepalives(external_cluster_context);
+    if (ret < 0) {
+      stop();
+      return ret;
+    }
+
+    ret = init_service_discovery_watchers(external_cluster_context);
+    if (ret < 0) {
+      stop();
+      return ret;
+    }
+
+    if (!external_cluster_context->check_keepalive_actor_start_success()) {
+      stop();
+      return -1;
+    }
+  }
+
   return 0;
 }
 
@@ -258,14 +292,27 @@ LIBATAPP_MACRO_API const char *ATFW_UTIL_MACRO_NONNULL service_discovery_module:
 LIBATAPP_MACRO_API service_discovery_module::service_discovery_cluster_context::service_discovery_cluster_context()
     : data_(std::make_shared<service_discovery_cluster_context_data>()) {}
 
-LIBATAPP_MACRO_API int service_discovery_module::stop() { return cluster_context_->stop(); }
+LIBATAPP_MACRO_API int service_discovery_module::stop() {
+  int ret = cluster_context_->stop();
+  for (const auto &external_cluster_context : external_cluster_contexts_) {
+    int ext_ret = external_cluster_context->stop();
+    if (ext_ret != 0) {
+      ret = ext_ret;
+    }
+  }
+  return ret;
+}
 
 LIBATAPP_MACRO_API int service_discovery_module::reload() {
+  // FIXME reload 不支持external cluster context的热更新，后续可以考虑增加这个功能
   return cluster_context_->reload(get_app()->get_origin_configure().etcd(), nullptr);
 }
 
 LIBATAPP_MACRO_API int service_discovery_module::tick() {
   cluster_context_->tick();
+  for (const auto &external_cluster_context : external_cluster_contexts_) {
+    external_cluster_context->tick();
+  }
 
   update_keepalive_topology_value();
   if (cluster_context_->get_etcd_module().get_etcd_cluster().check_flag(etcd_cluster::flag_t::kRunning)) {
@@ -277,6 +324,9 @@ LIBATAPP_MACRO_API int service_discovery_module::tick() {
 
 LIBATAPP_MACRO_API int service_discovery_module::timeout() {
   cluster_context_->reset();
+  for (const auto &external_cluster_context : external_cluster_contexts_) {
+    external_cluster_context->reset();
+  }
   return 0;
 }
 
@@ -296,13 +346,31 @@ LIBATAPP_MACRO_API void service_discovery_module::enable_discovery() {
   int ret = init_service_discovery_keepalives(cluster_context_);
   if (ret < 0) {
     discovery_enabled_ = false;
-    cluster_context_->reset_internal_watchers_and_keepalives();
+    reset_context_internal_watchers_and_keepalives();
+    return;
   }
 
   ret = init_service_discovery_watchers(cluster_context_);
   if (ret < 0) {
     discovery_enabled_ = false;
-    cluster_context_->reset_internal_watchers_and_keepalives();
+    reset_context_internal_watchers_and_keepalives();
+    return;
+  }
+
+  for (const auto &external_cluster_context : external_cluster_contexts_) {
+    ret = init_service_discovery_keepalives(external_cluster_context);
+    if (ret < 0) {
+      discovery_enabled_ = false;
+      reset_context_internal_watchers_and_keepalives();
+      return;
+    }
+
+    ret = init_service_discovery_watchers(external_cluster_context);
+    if (ret < 0) {
+      discovery_enabled_ = false;
+      reset_context_internal_watchers_and_keepalives();
+      return;
+    }
   }
 }
 
@@ -311,7 +379,14 @@ LIBATAPP_MACRO_API void service_discovery_module::disable_discovery() {
     return;
   }
   discovery_enabled_ = false;
+  reset_context_internal_watchers_and_keepalives();
+}
+
+LIBATAPP_MACRO_API void service_discovery_module::reset_context_internal_watchers_and_keepalives() {
   cluster_context_->reset_internal_watchers_and_keepalives();
+  for (const auto &external_cluster_context : external_cluster_contexts_) {
+    external_cluster_context->reset_internal_watchers_and_keepalives();
+  }
 }
 
 void service_discovery_module::update_keepalive_topology_value() {
@@ -392,48 +467,52 @@ void service_discovery_module::update_keepalive_discovery_value() {
 }
 
 LIBATAPP_MACRO_API int service_discovery_module::init_service_discovery_keepalives(
-    ::atfw::util::nostd::nonnull<std::shared_ptr<service_discovery_cluster_context>> context) {
+    const ::atfw::util::nostd::nonnull<std::shared_ptr<service_discovery_cluster_context>> &context) {
   // 先刷新topology数据，后刷新discovery数据，以保证策略路由变化时已获取到最新的topology信息
   update_keepalive_topology_value();
   update_keepalive_discovery_value();
 
   atframework::atapp::app &app = *get_app();
 
-  int ret = init_topology_keepalive(app, context, internal_keepalive_topology_value_);
-  if (ret < 0) {
-    return ret;
-  }
-  ret = init_discovery_keepalive_by_id(app, context, internal_keepalive_discovery_value_);
-  if (ret < 0) {
-    return ret;
-  }
-  ret = init_discovery_keepalive_by_name(app, context, internal_keepalive_discovery_value_);
-  if (ret < 0) {
-    return ret;
+  if (context->get_etcd_module().get_configure().keepalive().enabled()) {
+    int ret = init_topology_keepalive(app, context, internal_keepalive_topology_value_);
+    if (ret < 0) {
+      return ret;
+    }
+    ret = init_discovery_keepalive_by_id(app, context, internal_keepalive_discovery_value_);
+    if (ret < 0) {
+      return ret;
+    }
+    ret = init_discovery_keepalive_by_name(app, context, internal_keepalive_discovery_value_);
+    if (ret < 0) {
+      return ret;
+    }
   }
 
   return 0;
 }
 
 LIBATAPP_MACRO_API int service_discovery_module::init_service_discovery_watchers(
-    ::atfw::util::nostd::nonnull<std::shared_ptr<service_discovery_cluster_context>> context) {
+    const ::atfw::util::nostd::nonnull<std::shared_ptr<service_discovery_cluster_context>> &context) {
   // 先刷新topology数据，后刷新discovery数据，以保证策略路由变化时已获取到最新的topology信息
   update_keepalive_topology_value();
   update_keepalive_discovery_value();
 
   atframework::atapp::app &app = *get_app();
 
-  int ret = add_topology_watcher_callback(app, context, nullptr);
-  if (ret < 0) {
-    return ret;
-  }
-  ret = add_discovery_watcher_by_id_callback(app, context, nullptr);
-  if (ret < 0) {
-    return ret;
-  }
-  ret = add_discovery_watcher_by_name_callback(app, context, nullptr);
-  if (ret < 0) {
-    return ret;
+  if (context->get_etcd_module().get_configure().watcher().enabled()) {
+    int ret = add_topology_watcher_callback(app, context, nullptr);
+    if (ret < 0) {
+      return ret;
+    }
+    ret = add_discovery_watcher_by_id_callback(app, context, nullptr);
+    if (ret < 0) {
+      return ret;
+    }
+    ret = add_discovery_watcher_by_name_callback(app, context, nullptr);
+    if (ret < 0) {
+      return ret;
+    }
   }
 
   return 0;
@@ -441,7 +520,8 @@ LIBATAPP_MACRO_API int service_discovery_module::init_service_discovery_watchers
 
 LIBATAPP_MACRO_API int service_discovery_module::init_discovery_keepalive_by_id(
     atframework::atapp::app &app,
-    ::atfw::util::nostd::nonnull<std::shared_ptr<service_discovery_cluster_context>> context, std::string &value) {
+    const ::atfw::util::nostd::nonnull<std::shared_ptr<service_discovery_cluster_context>> &context,
+    std::string &value) {
   atapp::etcd_keepalive::ptr_t actor = add_keepalive_actor(
       app, context, value, get_discovery_by_id_path(app, context->etcd_module_.get_configure_path()));
   if (!actor) {
@@ -460,7 +540,8 @@ LIBATAPP_MACRO_API int service_discovery_module::init_discovery_keepalive_by_id(
 
 LIBATAPP_MACRO_API int service_discovery_module::init_discovery_keepalive_by_name(
     atframework::atapp::app &app,
-    ::atfw::util::nostd::nonnull<std::shared_ptr<service_discovery_cluster_context>> context, std::string &value) {
+    const ::atfw::util::nostd::nonnull<std::shared_ptr<service_discovery_cluster_context>> &context,
+    std::string &value) {
   atapp::etcd_keepalive::ptr_t actor = add_keepalive_actor(
       app, context, value, get_discovery_by_name_path(app, context->etcd_module_.get_configure_path()));
   if (!actor) {
@@ -479,7 +560,8 @@ LIBATAPP_MACRO_API int service_discovery_module::init_discovery_keepalive_by_nam
 
 LIBATAPP_MACRO_API int service_discovery_module::init_topology_keepalive(
     atframework::atapp::app &app,
-    ::atfw::util::nostd::nonnull<std::shared_ptr<service_discovery_cluster_context>> context, std::string &value) {
+    const ::atfw::util::nostd::nonnull<std::shared_ptr<service_discovery_cluster_context>> &context,
+    std::string &value) {
   atapp::etcd_keepalive::ptr_t actor =
       add_keepalive_actor(app, context, value, get_topology_path(app, context->etcd_module_.get_configure_path()));
   if (!actor) {
@@ -543,7 +625,7 @@ LIBATAPP_MACRO_API std::string service_discovery_module::get_topology_watcher_pa
 
 LIBATAPP_MACRO_API int service_discovery_module::init_discovery_watcher_by_id(
     ATFW_EXPLICIT_UNUSED_ATTR atframework::atapp::app &app,
-    ::atfw::util::nostd::nonnull<std::shared_ptr<service_discovery_cluster_context>> context) {
+    const ::atfw::util::nostd::nonnull<std::shared_ptr<service_discovery_cluster_context>> &context) {
   if (!context->data_->internal_discovery_watcher_by_id_) {
     std::string watch_path =
         LOG_WRAPPER_FWAPI_FORMAT("{}{}", context->etcd_module_.get_configure_path(), ETCD_MODULE_BY_ID_DIR);
@@ -572,7 +654,7 @@ LIBATAPP_MACRO_API int service_discovery_module::init_discovery_watcher_by_id(
 
 LIBATAPP_MACRO_API int service_discovery_module::init_discovery_watcher_by_name(
     ATFW_EXPLICIT_UNUSED_ATTR atframework::atapp::app &app,
-    ::atfw::util::nostd::nonnull<std::shared_ptr<service_discovery_cluster_context>> context) {
+    const ::atfw::util::nostd::nonnull<std::shared_ptr<service_discovery_cluster_context>> &context) {
   if (!context->data_->internal_discovery_watcher_by_name_) {
     // generate watch data
     std::string watch_path =
@@ -602,7 +684,7 @@ LIBATAPP_MACRO_API int service_discovery_module::init_discovery_watcher_by_name(
 
 LIBATAPP_MACRO_API int service_discovery_module::init_topology_watcher(
     ATFW_EXPLICIT_UNUSED_ATTR atframework::atapp::app &app,
-    ::atfw::util::nostd::nonnull<std::shared_ptr<service_discovery_cluster_context>> context) {
+    const ::atfw::util::nostd::nonnull<std::shared_ptr<service_discovery_cluster_context>> &context) {
   if (!context->data_->internal_topology_watcher_) {
     // generate watch data
     std::string watch_path =
@@ -693,7 +775,7 @@ LIBATAPP_MACRO_API void service_discovery_module::service_discovery_cluster_cont
 
 LIBATAPP_MACRO_API int service_discovery_module::add_discovery_watcher_by_id_callback(
     atframework::atapp::app &app,
-    ::atfw::util::nostd::nonnull<std::shared_ptr<service_discovery_cluster_context>> context,
+    const ::atfw::util::nostd::nonnull<std::shared_ptr<service_discovery_cluster_context>> &context,
     const discovery_watcher_list_callback_t &fn) {
   int ret = init_discovery_watcher_by_id(app, context);
   if (ret < 0) {
@@ -705,7 +787,7 @@ LIBATAPP_MACRO_API int service_discovery_module::add_discovery_watcher_by_id_cal
 
 LIBATAPP_MACRO_API int service_discovery_module::add_discovery_watcher_by_name_callback(
     atframework::atapp::app &app,
-    ::atfw::util::nostd::nonnull<std::shared_ptr<service_discovery_cluster_context>> context,
+    const ::atfw::util::nostd::nonnull<std::shared_ptr<service_discovery_cluster_context>> &context,
     const discovery_watcher_list_callback_t &fn) {
   int ret = init_discovery_watcher_by_name(app, context);
   if (ret < 0) {
@@ -717,7 +799,7 @@ LIBATAPP_MACRO_API int service_discovery_module::add_discovery_watcher_by_name_c
 
 LIBATAPP_MACRO_API int service_discovery_module::add_topology_watcher_callback(
     atframework::atapp::app &app,
-    ::atfw::util::nostd::nonnull<std::shared_ptr<service_discovery_cluster_context>> context,
+    const ::atfw::util::nostd::nonnull<std::shared_ptr<service_discovery_cluster_context>> &context,
     const topology_watcher_list_callback_t &fn) {
   int ret = init_topology_watcher(app, context);
   if (ret < 0) {
@@ -754,7 +836,7 @@ LIBATAPP_MACRO_API const std::string &service_discovery_module::get_configure_pa
 
 LIBATAPP_MACRO_API atapp::etcd_keepalive::ptr_t service_discovery_module::add_keepalive_actor(
     atframework::atapp::app &app,
-    ::atfw::util::nostd::nonnull<std::shared_ptr<service_discovery_cluster_context>> context, std::string &val,
+    const ::atfw::util::nostd::nonnull<std::shared_ptr<service_discovery_cluster_context>> &context, std::string &val,
     const std::string &node_path) {
   atapp::etcd_keepalive::ptr_t ret;
 
@@ -787,7 +869,7 @@ LIBATAPP_MACRO_API atapp::etcd_keepalive::ptr_t service_discovery_module::add_ke
 
 LIBATAPP_MACRO_API bool service_discovery_module::remove_keepalive_actor(
     ATFW_EXPLICIT_UNUSED_ATTR atframework::atapp::app &app,
-    ::atfw::util::nostd::nonnull<std::shared_ptr<service_discovery_cluster_context>> context,
+    const ::atfw::util::nostd::nonnull<std::shared_ptr<service_discovery_cluster_context>> &context,
     const atapp::etcd_keepalive::ptr_t &keepalive) {
   if (!keepalive) {
     return false;
@@ -952,13 +1034,13 @@ LIBATAPP_MACRO_API void service_discovery_module::remove_on_topology_snapshot_lo
 
 LIBATAPP_MACRO_API etcd_watcher::watch_event_fn_t_ptr
 service_discovery_module::create_discovery_watcher_callback_list_wrapper(
-    ::atfw::util::nostd::nonnull<std::shared_ptr<service_discovery_cluster_context>> context) {
+    const ::atfw::util::nostd::nonnull<std::shared_ptr<service_discovery_cluster_context>> &context) {
   return std::make_unique<etcd_watcher::watch_event_fn_t>(discovery_watcher_callback_list_wrapper_t(
       *this, context, ++context->data_->discovery_watcher_snapshot_index_allocator_));
 }
 LIBATAPP_MACRO_API etcd_watcher::watch_event_fn_t_ptr
 service_discovery_module::create_topology_watcher_callback_list_wrapper(
-    ::atfw::util::nostd::nonnull<std::shared_ptr<service_discovery_cluster_context>> context) {
+    const ::atfw::util::nostd::nonnull<std::shared_ptr<service_discovery_cluster_context>> &context) {
   return std::make_unique<etcd_watcher::watch_event_fn_t>(topology_watcher_callback_list_wrapper_t(
       *this, context, ++context->data_->topology_watcher_snapshot_index_allocator_));
 }
@@ -1160,8 +1242,8 @@ void service_discovery_module::watcher_internal_access_t::cleanup_old_topology_p
 }
 
 service_discovery_module::discovery_watcher_callback_list_wrapper_t::discovery_watcher_callback_list_wrapper_t(
-    service_discovery_module &m, ::atfw::util::nostd::nonnull<std::shared_ptr<service_discovery_cluster_context>> c,
-    int64_t index)
+    service_discovery_module &m,
+    const ::atfw::util::nostd::nonnull<std::shared_ptr<service_discovery_cluster_context>> &c, int64_t index)
     : mod(&m),
       ctx(c),
       callback_lock(nullptr),
@@ -1170,7 +1252,8 @@ service_discovery_module::discovery_watcher_callback_list_wrapper_t::discovery_w
       has_insert_snapshot_index(false) {}
 
 service_discovery_module::discovery_watcher_callback_list_wrapper_t::discovery_watcher_callback_list_wrapper_t(
-    service_discovery_module &m, ::atfw::util::nostd::nonnull<std::shared_ptr<service_discovery_cluster_context>> c,
+    service_discovery_module &m,
+    const ::atfw::util::nostd::nonnull<std::shared_ptr<service_discovery_cluster_context>> &c,
     std::recursive_mutex &lock, std::list<discovery_watcher_list_callback_t> &cbks, int64_t index)
     : mod(&m),
       ctx(c),
@@ -1180,8 +1263,8 @@ service_discovery_module::discovery_watcher_callback_list_wrapper_t::discovery_w
       has_insert_snapshot_index(false) {}
 
 service_discovery_module::discovery_watcher_callback_list_wrapper_t::~discovery_watcher_callback_list_wrapper_t() {
-  if (nullptr != ctx && 0 != snapshot_index && has_insert_snapshot_index) {
-    ctx->data_->discovery_watcher_snapshot_index_.erase(snapshot_index);
+  if (!ctx.expired() && 0 != snapshot_index && has_insert_snapshot_index) {
+    ctx.lock()->data_->discovery_watcher_snapshot_index_.erase(snapshot_index);
   }
 }
 
@@ -1191,19 +1274,23 @@ void service_discovery_module::discovery_watcher_callback_list_wrapper_t::operat
   if (nullptr == mod) {
     return;
   }
-  ctx->data_->last_etcd_event_discovery_header_ = header;
+  if (ctx.expired()) {
+    return;
+  }
+  auto ctx_locked = ctx.lock();
+  ctx_locked->data_->last_etcd_event_discovery_header_ = header;
 
   bool enable_snapshot = body.snapshot && 0 != snapshot_index;
   if (enable_snapshot) {
     if (!has_insert_snapshot_index) {
-      ctx->data_->discovery_watcher_snapshot_index_.insert(snapshot_index);
+      ctx_locked->data_->discovery_watcher_snapshot_index_.insert(snapshot_index);
       has_insert_snapshot_index = true;
     }
 
     // We just accept the earliest watcher as snapshot notifier.
     // So just enable by_id or by_name when initializing and they will has the smallest index.
-    if (!ctx->data_->discovery_watcher_snapshot_index_.empty() &&
-        *ctx->data_->discovery_watcher_snapshot_index_.begin() != snapshot_index) {
+    if (!ctx_locked->data_->discovery_watcher_snapshot_index_.empty() &&
+        *ctx_locked->data_->discovery_watcher_snapshot_index_.begin() != snapshot_index) {
       enable_snapshot = false;
     }
   }
@@ -1227,7 +1314,7 @@ void service_discovery_module::discovery_watcher_callback_list_wrapper_t::operat
   for (size_t i = 0; i < body.events.size(); ++i) {
     const ::atframework::atapp::etcd_watcher::event_t &evt_data = body.events[i];
     node_info_t node;
-    node.context_addr = reinterpret_cast<uintptr_t>(ctx.get());
+    node.context_addr = reinterpret_cast<uintptr_t>(ctx_locked.get());
     etcd_discovery_node::node_version current_node_version;
 
     unpack(node, evt_data.kv.key.empty() ? evt_data.prev_kv.key : evt_data.kv.key,
@@ -1272,7 +1359,7 @@ void service_discovery_module::discovery_watcher_callback_list_wrapper_t::operat
 
   // cleanup old nodes when receive snapshot response
   if (enable_snapshot) {
-    service_discovery_module::watcher_internal_access_t::cleanup_old_nodes(*mod, *ctx, old_names, old_ids);
+    service_discovery_module::watcher_internal_access_t::cleanup_old_nodes(*mod, *ctx_locked, old_names, old_ids);
 
     for (auto iter = mod->discovery_on_snapshot_loaded_callbacks_.begin();
          iter != mod->discovery_on_snapshot_loaded_callbacks_.end();) {
@@ -1286,8 +1373,8 @@ void service_discovery_module::discovery_watcher_callback_list_wrapper_t::operat
 }
 
 service_discovery_module::topology_watcher_callback_list_wrapper_t::topology_watcher_callback_list_wrapper_t(
-    service_discovery_module &m, ::atfw::util::nostd::nonnull<std::shared_ptr<service_discovery_cluster_context>> c,
-    int64_t index)
+    service_discovery_module &m,
+    const ::atfw::util::nostd::nonnull<std::shared_ptr<service_discovery_cluster_context>> &c, int64_t index)
     : mod(&m),
       ctx(c),
       callback_lock(nullptr),
@@ -1296,7 +1383,8 @@ service_discovery_module::topology_watcher_callback_list_wrapper_t::topology_wat
       has_insert_snapshot_index(false) {}
 
 service_discovery_module::topology_watcher_callback_list_wrapper_t::topology_watcher_callback_list_wrapper_t(
-    service_discovery_module &m, ::atfw::util::nostd::nonnull<std::shared_ptr<service_discovery_cluster_context>> c,
+    service_discovery_module &m,
+    const ::atfw::util::nostd::nonnull<std::shared_ptr<service_discovery_cluster_context>> &c,
     std::recursive_mutex &lock, std::list<topology_watcher_list_callback_t> &cbks, int64_t index)
     : mod(&m),
       ctx(c),
@@ -1306,8 +1394,8 @@ service_discovery_module::topology_watcher_callback_list_wrapper_t::topology_wat
       has_insert_snapshot_index(false) {}
 
 service_discovery_module::topology_watcher_callback_list_wrapper_t::~topology_watcher_callback_list_wrapper_t() {
-  if (nullptr != ctx && 0 != snapshot_index && has_insert_snapshot_index) {
-    ctx->data_->topology_watcher_snapshot_index_.erase(snapshot_index);
+  if (!ctx.expired() && 0 != snapshot_index && has_insert_snapshot_index) {
+    ctx.lock()->data_->topology_watcher_snapshot_index_.erase(snapshot_index);
   }
 }
 
@@ -1317,19 +1405,23 @@ void service_discovery_module::topology_watcher_callback_list_wrapper_t::operato
   if (nullptr == mod) {
     return;
   }
-  ctx->data_->last_etcd_event_topology_header_ = header;
+  if (ctx.expired()) {
+    return;
+  }
+  auto ctx_locked = ctx.lock();
+  ctx_locked->data_->last_etcd_event_topology_header_ = header;
 
   bool enable_snapshot = body.snapshot && 0 != snapshot_index;
   if (enable_snapshot) {
     if (!has_insert_snapshot_index) {
-      ctx->data_->topology_watcher_snapshot_index_.insert(snapshot_index);
+      ctx_locked->data_->topology_watcher_snapshot_index_.insert(snapshot_index);
       has_insert_snapshot_index = true;
     }
 
     // We just accept the earliest watcher as snapshot notifier.
     // So just enable by_id or by_name when initializing and they will has the smallest index.
-    if (!ctx->data_->topology_watcher_snapshot_index_.empty() &&
-        *ctx->data_->topology_watcher_snapshot_index_.begin() != snapshot_index) {
+    if (!ctx_locked->data_->topology_watcher_snapshot_index_.empty() &&
+        *ctx_locked->data_->topology_watcher_snapshot_index_.begin() != snapshot_index) {
       enable_snapshot = false;
     }
   }
@@ -1352,7 +1444,7 @@ void service_discovery_module::topology_watcher_callback_list_wrapper_t::operato
   for (size_t i = 0; i < body.events.size(); ++i) {
     const ::atframework::atapp::etcd_watcher::event_t &evt_data = body.events[i];
     topology_info_t topology_info;
-    topology_info.storage.context_addr = reinterpret_cast<uintptr_t>(ctx.get());
+    topology_info.storage.context_addr = reinterpret_cast<uintptr_t>(ctx_locked.get());
 
     unpack(topology_info, evt_data.kv.key.empty() ? evt_data.prev_kv.key : evt_data.kv.key,
            evt_data.kv.value.empty() ? evt_data.prev_kv.value : evt_data.kv.value, true);
@@ -1392,7 +1484,7 @@ void service_discovery_module::topology_watcher_callback_list_wrapper_t::operato
 
   // cleanup old nodes when receive snapshot response
   if (enable_snapshot) {
-    service_discovery_module::watcher_internal_access_t::cleanup_old_topology_peers(*mod, *ctx, old_ids);
+    service_discovery_module::watcher_internal_access_t::cleanup_old_topology_peers(*mod, *ctx_locked, old_ids);
 
     for (auto iter = mod->topology_on_snapshot_loaded_callbacks_.begin();
          iter != mod->topology_on_snapshot_loaded_callbacks_.end();) {
@@ -1420,8 +1512,8 @@ bool service_discovery_module::update_internal_watcher_event(node_info_t &node,
           // 只有相同 context 才进行处理
           LIBATAPP_MACRO_ETCD_CLUSTER_LOG_WARNING(
               cluster_context_->etcd_module_.get_etcd_cluster(),
-              "try to delete node with same id but different context, ignore it. node id: %lu, node name: %s, node "
-              "context: %p, local cache context: %p",
+              "try to delete node with same id but different context, ignore it. node id: {}, node name: {}, node "
+              "context: {}, local cache context: {}",
               node.node_discovery.id(), node.node_discovery.name().c_str(), reinterpret_cast<void *>(node.context_addr),
               reinterpret_cast<void *>(local_cache_by_id->get_context_addr()));
           return false;
@@ -1437,8 +1529,8 @@ bool service_discovery_module::update_internal_watcher_event(node_info_t &node,
           // 只有相同 context 才进行处理
           LIBATAPP_MACRO_ETCD_CLUSTER_LOG_WARNING(
               cluster_context_->etcd_module_.get_etcd_cluster(),
-              "try to delete node with same id but different context, ignore it. node id: %lu, node name: %s, node "
-              "context: %p, local cache context: %p",
+              "try to delete node with same id but different context, ignore it. node id: {}, node name: {}, node "
+              "context: {}, local cache context: {}",
               node.node_discovery.id(), node.node_discovery.name().c_str(), reinterpret_cast<void *>(node.context_addr),
               reinterpret_cast<void *>(local_cache_by_id->get_context_addr()));
           return false;
@@ -1467,8 +1559,8 @@ bool service_discovery_module::update_internal_watcher_event(node_info_t &node,
           // 只有相同 context 才进行处理
           LIBATAPP_MACRO_ETCD_CLUSTER_LOG_WARNING(
               cluster_context_->etcd_module_.get_etcd_cluster(),
-              "try to delete node with same id but different context, ignore it. node id: %lu, node name: %s, node "
-              "context: %p, local cache context: %p",
+              "try to delete node with same id but different context, ignore it. node id: {}, node name: {}, node "
+              "context: {}, local cache context: {}",
               node.node_discovery.id(), node.node_discovery.name().c_str(), reinterpret_cast<void *>(node.context_addr),
               reinterpret_cast<void *>(local_cache_by_id->get_context_addr()));
           local_cache_by_id = nullptr;
@@ -1483,8 +1575,8 @@ bool service_discovery_module::update_internal_watcher_event(node_info_t &node,
           // 只有相同 context 才进行处理
           LIBATAPP_MACRO_ETCD_CLUSTER_LOG_WARNING(
               cluster_context_->etcd_module_.get_etcd_cluster(),
-              "try to delete node with same name but different context, ignore it. node id: %lu, node name: %s, node "
-              "context: %p, local cache context: %p",
+              "try to delete node with same name but different context, ignore it. node id: {}, node name: {}, node "
+              "context: {}, local cache context: {}",
               node.node_discovery.id(), node.node_discovery.name().c_str(), reinterpret_cast<void *>(node.context_addr),
               reinterpret_cast<void *>(local_cache_by_name->get_context_addr()));
           local_cache_by_name = nullptr;
@@ -1603,7 +1695,7 @@ bool service_discovery_module::update_internal_watcher_event(topology_info_t &to
         // 已存在的节点不属于当前 context，视为过期或乱序事件，不触发回调
         LIBATAPP_MACRO_ETCD_CLUSTER_LOG_WARNING(
             cluster_context_->etcd_module_.get_etcd_cluster(),
-            "Received topology event with id %lu from context %p, but current context is %p, ignore it",
+            "Received topology event with id {} from context {}, but current context is {}, ignore it",
             topology_info.storage.info->id(), (void *)topology_info.storage.context_addr,
             (void *)local_cache_iter->second.context_addr);
         return false;
@@ -1675,4 +1767,4 @@ void service_discovery_module::service_discovery_cluster_context::reset_internal
   data_->internal_topology_keepalive_actors_.clear();
 }
 
-LIBATAPP_MACRO_NAMESPACE_END
\ No newline at end of file
+LIBATAPP_MACRO_NAMESPACE_END
diff --git a/test/case/atapp_etcd_module_test.cpp b/test/case/atapp_etcd_module_test.cpp
index 124357d..38ff368 100644
--- a/test/case/atapp_etcd_module_test.cpp
+++ b/test/case/atapp_etcd_module_test.cpp
@@ -1701,6 +1701,105 @@ CASE_TEST(atapp_etcd_module, multi_context_snapshot_isolation) {
   }
 
   // Phase 3: 上线节点到新的context
+  std::weak_ptr<atapp::service_discovery_module::service_discovery_cluster_context> weak_context;
+  {
+    atframework::atapp::app app3;
+    const char *args3[] = {"app3", "-c", conf_path_3.c_str(), "start"};
+    CASE_EXPECT_EQ(0, app3.init(nullptr, 4, args3, nullptr));
+    auto discovery3 = app3.get_service_discovery_module();
+    CASE_EXPECT_TRUE(!!discovery3);
+    if (!discovery3) {
+      return;
+    }
+
+    // Phase 4: app1接入新节点 context
+    auto service_discovery_context =
+        std::make_shared<atframework::atapp::service_discovery_module::service_discovery_cluster_context>();
+    weak_context = service_discovery_context;
+    int ret = service_discovery_context->init(app1, discovery3->get_configure(), nullptr);
+    CASE_EXPECT_TRUE(ret == 0);
+    if (ret != 0) {
+      return;
+    }
+
+    ret = discovery1->init_service_discovery_keepalives(service_discovery_context);
+    CASE_EXPECT_TRUE(ret == 0);
+    if (ret != 0) {
+      return;
+    }
+    ret = discovery1->init_service_discovery_watchers(service_discovery_context);
+    CASE_EXPECT_TRUE(ret == 0);
+    if (ret != 0) {
+      return;
+    }
+    bool success = service_discovery_context->check_keepalive_actor_start_success();
+    CASE_EXPECT_TRUE(success);
+    if (!success) {
+      return;
+    }
+
+    // Phase 5: 等待发现app3
+    apps = {&app1, &app3};
+    bool mutual_discovery = run_apps_until(apps, [&discovery1, &discovery3, &app1, &app3]() {
+      return !!discovery1->get_global_discovery().get_node_by_id(app3.get_id()) &&
+             !!discovery3->get_global_discovery().get_node_by_id(app1.get_id());
+    });
+    CASE_EXPECT_TRUE(mutual_discovery);
+    if (!mutual_discovery) {
+      return;
+    }
+    CASE_EXPECT_TRUE(!!discovery1->get_global_discovery().get_node_by_id(app3.get_id()));
+    CASE_EXPECT_TRUE(!!discovery1->get_global_discovery().get_node_by_id(app1.get_id()));
+    CASE_EXPECT_TRUE(!!discovery3->get_global_discovery().get_node_by_id(app1.get_id()));
+    CASE_EXPECT_TRUE(!!discovery3->get_global_discovery().get_node_by_id(app3.get_id()));
+  }
+  // Phase 6 检查泄露
+  CASE_EXPECT_TRUE(weak_context.expired());
+}
+
+// ============================================================
+// I.5.7: diff_context_snapshot_isolation
+// 验证 context 冲突时不会被替换
+// ============================================================
+CASE_TEST(atapp_etcd_module, diff_context_snapshot_isolation) {
+  if (!is_etcd_available()) {
+    CASE_MSG_INFO() << CASE_MSG_FCOLOR(YELLOW) << "etcd is not available at " << get_etcd_host() << ", skip this test"
+                    << '\n';
+    return;
+  }
+
+  std::string conf_path_base;
+  atfw::util::file_system::dirname(__FILE__, 0, conf_path_base);
+  std::string conf_path_1 = conf_path_base + "/atapp_test_etcd_module_node1.yaml";
+  std::string conf_path_2 = conf_path_base + "/atapp_test_etcd_module_multi_context_node2.yaml";
+  std::string conf_path_3 = conf_path_base + "/atapp_test_etcd_module_multi_context_node3.yaml";
+
+  if (!atfw::util::file_system::is_exist(conf_path_1.c_str()) ||
+      !atfw::util::file_system::is_exist(conf_path_2.c_str()) ||
+      !atfw::util::file_system::is_exist(conf_path_3.c_str())) {
+    CASE_MSG_INFO() << CASE_MSG_FCOLOR(YELLOW) << "etcd node config not found, skip this test" << '\n';
+    return;
+  }
+
+  atframework::atapp::app app1;
+  const char *args1[] = {"app1", "-c", conf_path_1.c_str(), "start"};
+  CASE_EXPECT_EQ(0, app1.init(nullptr, 4, args1, nullptr));
+
+  auto discovery1 = app1.get_service_discovery_module();
+  CASE_EXPECT_TRUE(!!discovery1);
+  if (!discovery1) {
+    return;
+  }
+
+  atframework::atapp::app app2;
+  const char *args2[] = {"app2", "-c", conf_path_2.c_str(), "start"};
+  CASE_EXPECT_EQ(0, app2.init(nullptr, 4, args2, nullptr));
+  auto discovery2 = app2.get_service_discovery_module();
+  CASE_EXPECT_TRUE(!!discovery2);
+  if (!discovery2) {
+    return;
+  }
+
   atframework::atapp::app app3;
   const char *args3[] = {"app3", "-c", conf_path_3.c_str(), "start"};
   CASE_EXPECT_EQ(0, app3.init(nullptr, 4, args3, nullptr));
@@ -1710,43 +1809,212 @@ CASE_TEST(atapp_etcd_module, multi_context_snapshot_isolation) {
     return;
   }
 
-  // Phase 4: app1接入新节点 context
-  auto service_discovery_context =
+  auto service_discovery_context_a =
       std::make_shared<atframework::atapp::service_discovery_module::service_discovery_cluster_context>();
-  int ret = service_discovery_context->init(app1, discovery3->get_configure(), nullptr);
+  int ret = service_discovery_context_a->init(app1, discovery2->get_configure(), nullptr);
   CASE_EXPECT_TRUE(ret == 0);
   if (ret != 0) {
     return;
   }
 
-  ret = discovery1->init_service_discovery_keepalives(service_discovery_context);
+  ret = discovery1->init_service_discovery_watchers(service_discovery_context_a);
   CASE_EXPECT_TRUE(ret == 0);
   if (ret != 0) {
     return;
   }
-  ret = discovery1->init_service_discovery_watchers(service_discovery_context);
+  bool success = service_discovery_context_a->check_keepalive_actor_start_success();
+  CASE_EXPECT_TRUE(success);
+  if (!success) {
+    return;
+  }
+
+  auto service_discovery_context_b =
+      std::make_shared<atframework::atapp::service_discovery_module::service_discovery_cluster_context>();
+  ret = service_discovery_context_b->init(app1, discovery3->get_configure(), nullptr);
+  CASE_EXPECT_TRUE(ret == 0);
+  if (ret != 0) {
+    return;
+  }
+
+  ret = discovery1->init_service_discovery_watchers(service_discovery_context_b);
   CASE_EXPECT_TRUE(ret == 0);
   if (ret != 0) {
     return;
   }
-  bool success = service_discovery_context->check_keepalive_actor_start_success();
+  success = service_discovery_context_b->check_keepalive_actor_start_success();
   CASE_EXPECT_TRUE(success);
   if (!success) {
     return;
   }
 
-  // Phase 5: 等待发现app3
-  apps = {&app1, &app3};
-  bool mutual_discovery = run_apps_until(apps, [&discovery1, &discovery3, &app1, &app3]() {
-    return !!discovery1->get_global_discovery().get_node_by_id(app3.get_id()) &&
-           !!discovery3->get_global_discovery().get_node_by_id(app1.get_id());
-  });
+  // Phase 5: 等待发现并检查是否为app2的listener地址（如果app3覆盖了app2的snapshot，则会看到app3的地址）
+  std::vector<atframework::atapp::app *> apps = {&app1, &app2, &app3};
+  bool mutual_discovery = run_apps_until(
+      apps, [&discovery1, &app2]() { return !!discovery1->get_global_discovery().get_node_by_id(app2.get_id()); });
   CASE_EXPECT_TRUE(mutual_discovery);
   if (!mutual_discovery) {
     return;
   }
-  CASE_EXPECT_TRUE(!!discovery1->get_global_discovery().get_node_by_id(app3.get_id()));
-  CASE_EXPECT_TRUE(!!discovery1->get_global_discovery().get_node_by_id(app1.get_id()));
-  CASE_EXPECT_TRUE(!!discovery3->get_global_discovery().get_node_by_id(app1.get_id()));
-  CASE_EXPECT_TRUE(!!discovery3->get_global_discovery().get_node_by_id(app3.get_id()));
+  auto node = discovery1->get_global_discovery().get_node_by_id(app2.get_id());
+  CASE_EXPECT_TRUE(!!node);
+  if (!node) {
+    return;
+  }
+  CASE_EXPECT_TRUE(*node->get_discovery_info().listen().begin() == "ipv4://127.0.0.1:22302");
+}
+
+// ============================================================
+// I.5.8: external_discovery_mutual_with_self
+//   Scenario 1: Both apps see each other AND themselves.
+//
+//   Config:
+//     app1: default pathA (watcher ✓, keepalive ✓)
+//           external pathB (watcher ✗, keepalive ✓)
+//     app2: default pathB (watcher ✓, keepalive ✓)
+//           external pathA (watcher ✗, keepalive ✓)
+//
+//   app1 keepalives on both pathA and pathB, but only watches pathA.
+//   app2 keepalives on both pathA and pathB, but only watches pathB.
+//
+//   Since both apps keepalive on both paths:
+//     - app1 watches pathA → sees app1 (keepalive on pathA) + app2 (keepalive on pathA via external)
+//     - app2 watches pathB → sees app1 (keepalive on pathB via external) + app2 (keepalive on pathB)
+//   Both apps see each other AND themselves.
+// ============================================================
+CASE_TEST(atapp_etcd_module, external_discovery_mutual_with_self) {
+  if (!is_etcd_available()) {
+    CASE_MSG_INFO() << CASE_MSG_FCOLOR(YELLOW) << "etcd is not available at " << get_etcd_host() << ", skip this test"
+                    << '\n';
+    return;
+  }
+
+  std::string conf_path_base;
+  atfw::util::file_system::dirname(__FILE__, 0, conf_path_base);
+  std::string conf_path_1 = conf_path_base + "/atapp_test_etcd_module_ext_disc_node1a.yaml";
+  std::string conf_path_2 = conf_path_base + "/atapp_test_etcd_module_ext_disc_node1b.yaml";
+
+  if (!atfw::util::file_system::is_exist(conf_path_1.c_str()) ||
+      !atfw::util::file_system::is_exist(conf_path_2.c_str())) {
+    CASE_MSG_INFO() << CASE_MSG_FCOLOR(YELLOW) << "etcd external discovery config not found, skip this test" << '\n';
+    return;
+  }
+
+  atframework::atapp::app app1;
+  atframework::atapp::app app2;
+  const char *args1[] = {"app1", "-c", conf_path_1.c_str(), "start"};
+  const char *args2[] = {"app2", "-c", conf_path_2.c_str(), "start"};
+  CASE_EXPECT_EQ(0, app1.init(nullptr, 4, args1, nullptr));
+  CASE_EXPECT_EQ(0, app2.init(nullptr, 4, args2, nullptr));
+
+  auto discovery1 = app1.get_service_discovery_module();
+  auto discovery2 = app2.get_service_discovery_module();
+  CASE_EXPECT_TRUE(!!discovery1);
+  CASE_EXPECT_TRUE(!!discovery2);
+  if (!discovery1 || !discovery2) {
+    return;
+  }
+
+  std::vector<atframework::atapp::app *> apps = {&app1, &app2};
+
+  // Wait for both apps to see each other
+  bool mutual = run_apps_until(apps, [&discovery1, &discovery2, &app1, &app2]() {
+    return !!discovery1->get_global_discovery().get_node_by_id(app2.get_id()) &&
+           !!discovery2->get_global_discovery().get_node_by_id(app1.get_id());
+  });
+  CASE_EXPECT_TRUE(mutual);
+
+  // Both apps should also see themselves
+  // app1 keeps alive on pathA (default) and pathB (external). app1 watches pathA → sees itself.
+  // app2 keeps alive on pathB (default) and pathA (external). app2 watches pathB → sees itself.
+  bool app1_sees_self = run_apps_until(
+      apps, [&discovery1, &app1]() { return !!discovery1->get_global_discovery().get_node_by_id(app1.get_id()); });
+  CASE_EXPECT_TRUE(app1_sees_self);
+
+  bool app2_sees_self = run_apps_until(
+      apps, [&discovery2, &app2]() { return !!discovery2->get_global_discovery().get_node_by_id(app2.get_id()); });
+  CASE_EXPECT_TRUE(app2_sees_self);
+
+  CASE_MSG_INFO() << "external_discovery_mutual_with_self: mutual=" << (mutual ? "true" : "false")
+                  << " app1_self=" << (app1_sees_self ? "true" : "false")
+                  << " app2_self=" << (app2_sees_self ? "true" : "false") << '\n';
+}
+
+// ============================================================
+// I.5.9: external_discovery_cross_only
+//   Scenario 2: Both apps see only the other, NOT themselves.
+//
+//   Config:
+//     app1: default pathA (watcher ✗, keepalive ✓)
+//           external pathB (watcher ✓, keepalive ✗)
+//     app2: default pathB (watcher ✗, keepalive ✓)
+//           external pathA (watcher ✓, keepalive ✗)
+//
+//   app1 keepalives on pathA only, but watches pathB only.
+//   app2 keepalives on pathB only, but watches pathA only.
+//
+//   Since keepalive and watcher are on different paths:
+//     - app1 watches pathB → sees app2 (keepalive on pathB) but NOT app1 (no keepalive on pathB)
+//     - app2 watches pathA → sees app1 (keepalive on pathA) but NOT app2 (no keepalive on pathA)
+//   Both apps see only the other, not themselves.
+// ============================================================
+CASE_TEST(atapp_etcd_module, external_discovery_cross_only) {
+  if (!is_etcd_available()) {
+    CASE_MSG_INFO() << CASE_MSG_FCOLOR(YELLOW) << "etcd is not available at " << get_etcd_host() << ", skip this test"
+                    << '\n';
+    return;
+  }
+
+  std::string conf_path_base;
+  atfw::util::file_system::dirname(__FILE__, 0, conf_path_base);
+  std::string conf_path_1 = conf_path_base + "/atapp_test_etcd_module_ext_disc_node2a.yaml";
+  std::string conf_path_2 = conf_path_base + "/atapp_test_etcd_module_ext_disc_node2b.yaml";
+
+  if (!atfw::util::file_system::is_exist(conf_path_1.c_str()) ||
+      !atfw::util::file_system::is_exist(conf_path_2.c_str())) {
+    CASE_MSG_INFO() << CASE_MSG_FCOLOR(YELLOW) << "etcd external discovery config not found, skip this test" << '\n';
+    return;
+  }
+
+  atframework::atapp::app app1;
+  atframework::atapp::app app2;
+  const char *args1[] = {"app1", "-c", conf_path_1.c_str(), "start"};
+  const char *args2[] = {"app2", "-c", conf_path_2.c_str(), "start"};
+  CASE_EXPECT_EQ(0, app1.init(nullptr, 4, args1, nullptr));
+  CASE_EXPECT_EQ(0, app2.init(nullptr, 4, args2, nullptr));
+
+  auto discovery1 = app1.get_service_discovery_module();
+  auto discovery2 = app2.get_service_discovery_module();
+  CASE_EXPECT_TRUE(!!discovery1);
+  CASE_EXPECT_TRUE(!!discovery2);
+  if (!discovery1 || !discovery2) {
+    return;
+  }
+
+  std::vector<atframework::atapp::app *> apps = {&app1, &app2};
+
+  // Wait for cross-discovery: app1 sees app2, app2 sees app1
+  bool cross_discovery = run_apps_until(apps, [&discovery1, &discovery2, &app1, &app2]() {
+    return !!discovery1->get_global_discovery().get_node_by_id(app2.get_id()) &&
+           !!discovery2->get_global_discovery().get_node_by_id(app1.get_id());
+  });
+  CASE_EXPECT_TRUE(cross_discovery);
+
+  // Give extra ticks to ensure snapshots are fully processed
+  run_apps_noblock(apps, 32);
+
+  // app1 should NOT see itself (keepalives on pathA, but watches pathB)
+  auto app1_self = discovery1->get_global_discovery().get_node_by_id(app1.get_id());
+  CASE_EXPECT_TRUE(!app1_self);
+
+  // app2 should NOT see itself (keepalives on pathB, but watches pathA)
+  auto app2_self = discovery2->get_global_discovery().get_node_by_id(app2.get_id());
+  CASE_EXPECT_TRUE(!app2_self);
+
+  // Both should still see each other
+  CASE_EXPECT_TRUE(!!discovery1->get_global_discovery().get_node_by_id(app2.get_id()));
+  CASE_EXPECT_TRUE(!!discovery2->get_global_discovery().get_node_by_id(app1.get_id()));
+
+  CASE_MSG_INFO() << "external_discovery_cross_only: cross=" << (cross_discovery ? "true" : "false")
+                  << " app1_self=" << (app1_self ? "found" : "null") << " app2_self=" << (app2_self ? "found" : "null")
+                  << '\n';
 }
diff --git a/test/case/atapp_test_etcd_module_ext_disc_node1a.yaml b/test/case/atapp_test_etcd_module_ext_disc_node1a.yaml
new file mode 100644
index 0000000..322d664
--- /dev/null
+++ b/test/case/atapp_test_etcd_module_ext_disc_node1a.yaml
@@ -0,0 +1,105 @@
+# Copyright 2026 atframework
+# External discovery test - Scenario 1, app1
+# Default pathA: watcher ✓, keepalive ✓
+# External pathB: watcher ✗, keepalive ✓
+# Expected: app1 sees both itself and app2
+atapp:
+  id: 0x00000901
+  id_mask: 8.8.8.8
+  name: "etcd-ext-disc-node1"
+  type_id: 9
+  type_name: "etcd-ext-disc-test"
+
+  bus:
+    listen: "ipv4://127.0.0.1:22401"
+    proxy: ""
+    backlog: 256
+    access_token_max_number: 5
+    overwrite_listen_path: false
+    topology:
+      rule:
+        allow_direct_connection: true
+        require_same_upstream: false
+    first_idle_timeout: 10s
+    ping_interval: 60s
+    retry_interval: 3s
+    fault_tolerant: 3
+    message_size: 64KB
+    receive_buffer_size: 1MB
+    send_buffer_size: 1MB
+    send_buffer_number: 0
+  timer:
+    tick_interval: 8ms
+    stop_timeout: 3s
+    stop_interval: 256ms
+  etcd:
+    enable: true
+    hosts:
+      - "${ATAPP_UNIT_TEST_ETCD_HOST:-http://127.0.0.1:12379}"
+    path: "/atapp/unit-test/external_discovery/pathA"
+    init:
+      timeout: "15s"
+      tick_interval: "64ms"
+    keepalive:
+      enabled: true
+      timeout: "16s"
+      ttl: "5s"
+      retry_interval: "3s"
+    request:
+      timeout: "5s"
+      initialization_timeout: "3s"
+    watcher:
+      enabled: true
+      retry_interval: "3s"
+      request_timeout: "3600s"
+      get_request_timeout: "180s"
+  external_discovery:
+    - enable: true
+      hosts:
+        - "${ATAPP_UNIT_TEST_ETCD_HOST:-http://127.0.0.1:12379}"
+      path: "/atapp/unit-test/external_discovery/pathB"
+      init:
+        timeout: "15s"
+        tick_interval: "64ms"
+      keepalive:
+        enabled: true
+        timeout: "16s"
+        ttl: "5s"
+        retry_interval: "3s"
+      request:
+        timeout: "5s"
+        initialization_timeout: "3s"
+      watcher:
+        enabled: false
+        retry_interval: "3s"
+        request_timeout: "3600s"
+        get_request_timeout: "180s"
+
+  log:
+    level: debug
+    category:
+      - name: default
+        prefix: "[Log %L][%F %T.%f][%s:%n(%C)]: "
+        stacktrace:
+          min: disable
+          max: disable
+        sink:
+          - type: file
+            level:
+              min: fatal
+              max: debug
+            rotate:
+              number: 10
+              size: 10485760
+            file: "../log/etcd-ext-disc-node1a.%N.log"
+            writing_alias: "../log/etcd-ext-disc-node1a.log"
+            auto_flush: info
+            flush_interval: 1s
+          - type: stderr
+            level:
+              min: fatal
+              max: warning
+          - type: stdout
+            level:
+              min: fatal
+              max: debug
diff --git a/test/case/atapp_test_etcd_module_ext_disc_node1b.yaml b/test/case/atapp_test_etcd_module_ext_disc_node1b.yaml
new file mode 100644
index 0000000..0ba6485
--- /dev/null
+++ b/test/case/atapp_test_etcd_module_ext_disc_node1b.yaml
@@ -0,0 +1,105 @@
+# Copyright 2026 atframework
+# External discovery test - Scenario 1, app2
+# Default pathB: watcher ✓, keepalive ✓
+# External pathA: watcher ✗, keepalive ✓
+# Expected: app2 sees both itself and app1
+atapp:
+  id: 0x00000902
+  id_mask: 8.8.8.8
+  name: "etcd-ext-disc-node2"
+  type_id: 9
+  type_name: "etcd-ext-disc-test"
+
+  bus:
+    listen: "ipv4://127.0.0.1:22402"
+    proxy: ""
+    backlog: 256
+    access_token_max_number: 5
+    overwrite_listen_path: false
+    topology:
+      rule:
+        allow_direct_connection: true
+        require_same_upstream: false
+    first_idle_timeout: 10s
+    ping_interval: 60s
+    retry_interval: 3s
+    fault_tolerant: 3
+    message_size: 64KB
+    receive_buffer_size: 1MB
+    send_buffer_size: 1MB
+    send_buffer_number: 0
+  timer:
+    tick_interval: 8ms
+    stop_timeout: 3s
+    stop_interval: 256ms
+  etcd:
+    enable: true
+    hosts:
+      - "${ATAPP_UNIT_TEST_ETCD_HOST:-http://127.0.0.1:12379}"
+    path: "/atapp/unit-test/external_discovery/pathB"
+    init:
+      timeout: "15s"
+      tick_interval: "64ms"
+    keepalive:
+      enabled: true
+      timeout: "16s"
+      ttl: "5s"
+      retry_interval: "3s"
+    request:
+      timeout: "5s"
+      initialization_timeout: "3s"
+    watcher:
+      enabled: true
+      retry_interval: "3s"
+      request_timeout: "3600s"
+      get_request_timeout: "180s"
+  external_discovery:
+    - enable: true
+      hosts:
+        - "${ATAPP_UNIT_TEST_ETCD_HOST:-http://127.0.0.1:12379}"
+      path: "/atapp/unit-test/external_discovery/pathA"
+      init:
+        timeout: "15s"
+        tick_interval: "64ms"
+      keepalive:
+        enabled: true
+        timeout: "16s"
+        ttl: "5s"
+        retry_interval: "3s"
+      request:
+        timeout: "5s"
+        initialization_timeout: "3s"
+      watcher:
+        enabled: false
+        retry_interval: "3s"
+        request_timeout: "3600s"
+        get_request_timeout: "180s"
+
+  log:
+    level: debug
+    category:
+      - name: default
+        prefix: "[Log %L][%F %T.%f][%s:%n(%C)]: "
+        stacktrace:
+          min: disable
+          max: disable
+        sink:
+          - type: file
+            level:
+              min: fatal
+              max: debug
+            rotate:
+              number: 10
+              size: 10485760
+            file: "../log/etcd-ext-disc-node1b.%N.log"
+            writing_alias: "../log/etcd-ext-disc-node1b.log"
+            auto_flush: info
+            flush_interval: 1s
+          - type: stderr
+            level:
+              min: fatal
+              max: warning
+          - type: stdout
+            level:
+              min: fatal
+              max: debug
diff --git a/test/case/atapp_test_etcd_module_ext_disc_node2a.yaml b/test/case/atapp_test_etcd_module_ext_disc_node2a.yaml
new file mode 100644
index 0000000..c3a7b3f
--- /dev/null
+++ b/test/case/atapp_test_etcd_module_ext_disc_node2a.yaml
@@ -0,0 +1,105 @@
+# Copyright 2026 atframework
+# External discovery test - Scenario 2, app1
+# Default pathA: watcher ✗, keepalive ✓
+# External pathB: watcher ✓, keepalive ✗
+# Expected: app1 sees app2 but NOT itself
+atapp:
+  id: 0x00000901
+  id_mask: 8.8.8.8
+  name: "etcd-ext-disc-node1"
+  type_id: 9
+  type_name: "etcd-ext-disc-test"
+
+  bus:
+    listen: "ipv4://127.0.0.1:22401"
+    proxy: ""
+    backlog: 256
+    access_token_max_number: 5
+    overwrite_listen_path: false
+    topology:
+      rule:
+        allow_direct_connection: true
+        require_same_upstream: false
+    first_idle_timeout: 10s
+    ping_interval: 60s
+    retry_interval: 3s
+    fault_tolerant: 3
+    message_size: 64KB
+    receive_buffer_size: 1MB
+    send_buffer_size: 1MB
+    send_buffer_number: 0
+  timer:
+    tick_interval: 8ms
+    stop_timeout: 3s
+    stop_interval: 256ms
+  etcd:
+    enable: true
+    hosts:
+      - "${ATAPP_UNIT_TEST_ETCD_HOST:-http://127.0.0.1:12379}"
+    path: "/atapp/unit-test/external_discovery/pathA"
+    init:
+      timeout: "15s"
+      tick_interval: "64ms"
+    keepalive:
+      enabled: true
+      timeout: "16s"
+      ttl: "5s"
+      retry_interval: "3s"
+    request:
+      timeout: "5s"
+      initialization_timeout: "3s"
+    watcher:
+      enabled: false
+      retry_interval: "3s"
+      request_timeout: "3600s"
+      get_request_timeout: "180s"
+  external_discovery:
+    - enable: true
+      hosts:
+        - "${ATAPP_UNIT_TEST_ETCD_HOST:-http://127.0.0.1:12379}"
+      path: "/atapp/unit-test/external_discovery/pathB"
+      init:
+        timeout: "15s"
+        tick_interval: "64ms"
+      keepalive:
+        enabled: false
+        timeout: "16s"
+        ttl: "5s"
+        retry_interval: "3s"
+      request:
+        timeout: "5s"
+        initialization_timeout: "3s"
+      watcher:
+        enabled: true
+        retry_interval: "3s"
+        request_timeout: "3600s"
+        get_request_timeout: "180s"
+
+  log:
+    level: debug
+    category:
+      - name: default
+        prefix: "[Log %L][%F %T.%f][%s:%n(%C)]: "
+        stacktrace:
+          min: disable
+          max: disable
+        sink:
+          - type: file
+            level:
+              min: fatal
+              max: debug
+            rotate:
+              number: 10
+              size: 10485760
+            file: "../log/etcd-ext-disc-node2a.%N.log"
+            writing_alias: "../log/etcd-ext-disc-node2a.log"
+            auto_flush: info
+            flush_interval: 1s
+          - type: stderr
+            level:
+              min: fatal
+              max: warning
+          - type: stdout
+            level:
+              min: fatal
+              max: debug
diff --git a/test/case/atapp_test_etcd_module_ext_disc_node2b.yaml b/test/case/atapp_test_etcd_module_ext_disc_node2b.yaml
new file mode 100644
index 0000000..e574502
--- /dev/null
+++ b/test/case/atapp_test_etcd_module_ext_disc_node2b.yaml
@@ -0,0 +1,105 @@
+# Copyright 2026 atframework
+# External discovery test - Scenario 2, app2
+# Default pathB: watcher ✗, keepalive ✓
+# External pathA: watcher ✓, keepalive ✗
+# Expected: app2 sees app1 but NOT itself
+atapp:
+  id: 0x00000902
+  id_mask: 8.8.8.8
+  name: "etcd-ext-disc-node2"
+  type_id: 9
+  type_name: "etcd-ext-disc-test"
+
+  bus:
+    listen: "ipv4://127.0.0.1:22402"
+    proxy: ""
+    backlog: 256
+    access_token_max_number: 5
+    overwrite_listen_path: false
+    topology:
+      rule:
+        allow_direct_connection: true
+        require_same_upstream: false
+    first_idle_timeout: 10s
+    ping_interval: 60s
+    retry_interval: 3s
+    fault_tolerant: 3
+    message_size: 64KB
+    receive_buffer_size: 1MB
+    send_buffer_size: 1MB
+    send_buffer_number: 0
+  timer:
+    tick_interval: 8ms
+    stop_timeout: 3s
+    stop_interval: 256ms
+  etcd:
+    enable: true
+    hosts:
+      - "${ATAPP_UNIT_TEST_ETCD_HOST:-http://127.0.0.1:12379}"
+    path: "/atapp/unit-test/external_discovery/pathB"
+    init:
+      timeout: "15s"
+      tick_interval: "64ms"
+    keepalive:
+      enabled: true
+      timeout: "16s"
+      ttl: "5s"
+      retry_interval: "3s"
+    request:
+      timeout: "5s"
+      initialization_timeout: "3s"
+    watcher:
+      enabled: false
+      retry_interval: "3s"
+      request_timeout: "3600s"
+      get_request_timeout: "180s"
+  external_discovery:
+    - enable: true
+      hosts:
+        - "${ATAPP_UNIT_TEST_ETCD_HOST:-http://127.0.0.1:12379}"
+      path: "/atapp/unit-test/external_discovery/pathA"
+      init:
+        timeout: "15s"
+        tick_interval: "64ms"
+      keepalive:
+        enabled: false
+        timeout: "16s"
+        ttl: "5s"
+        retry_interval: "3s"
+      request:
+        timeout: "5s"
+        initialization_timeout: "3s"
+      watcher:
+        enabled: true
+        retry_interval: "3s"
+        request_timeout: "3600s"
+        get_request_timeout: "180s"
+
+  log:
+    level: debug
+    category:
+      - name: default
+        prefix: "[Log %L][%F %T.%f][%s:%n(%C)]: "
+        stacktrace:
+          min: disable
+          max: disable
+        sink:
+          - type: file
+            level:
+              min: fatal
+              max: debug
+            rotate:
+              number: 10
+              size: 10485760
+            file: "../log/etcd-ext-disc-node2b.%N.log"
+            writing_alias: "../log/etcd-ext-disc-node2b.log"
+            auto_flush: info
+            flush_interval: 1s
+          - type: stderr
+            level:
+              min: fatal
+              max: warning
+          - type: stdout
+            level:
+              min: fatal
+              max: debug
diff --git a/test/case/atapp_test_etcd_module_multi_context_node3.yaml b/test/case/atapp_test_etcd_module_multi_context_node3.yaml
new file mode 100644
index 0000000..b2d9ade
--- /dev/null
+++ b/test/case/atapp_test_etcd_module_multi_context_node3.yaml
@@ -0,0 +1,78 @@
+# Copyright 2026 atframework
+atapp:
+  id: 0x00000802
+  id_mask: 8.8.8.8
+  name: "etcd-test-node2"
+  type_id: 8
+  type_name: "etcd-multi-test"
+
+  bus:
+    listen: "ipv4://127.0.0.1:22303"
+    proxy: ""
+    backlog: 256
+    access_token_max_number: 5
+    overwrite_listen_path: false
+    topology:
+      rule:
+        allow_direct_connection: true
+        require_same_upstream: false
+    first_idle_timeout: 10s
+    ping_interval: 60s
+    retry_interval: 3s
+    fault_tolerant: 3
+    message_size: 64KB
+    receive_buffer_size: 1MB
+    send_buffer_size: 1MB
+    send_buffer_number: 0
+  timer:
+    tick_interval: 8ms
+    stop_timeout: 3s
+    stop_interval: 256ms
+  etcd:
+    enable: true
+    hosts:
+      - "${ATAPP_UNIT_TEST_ETCD_HOST:-http://127.0.0.1:12379}"
+    path: "/atapp/unit-test/atapp_etcd_module/libatapp_extra_ctx_2"
+    init:
+      timeout: "15s"
+      tick_interval: "64ms"
+    keepalive:
+      timeout: "16s"
+      ttl: "5s"
+      retry_interval: "3s"
+    request:
+      timeout: "5s"
+      initialization_timeout: "3s"
+    watcher:
+      retry_interval: "3s"
+      request_timeout: "3600s"
+      get_request_timeout: "180s"
+
+  log:
+    level: debug
+    category:
+      - name: default
+        prefix: "[Log %L][%F %T.%f][%s:%n(%C)]: "
+        stacktrace:
+          min: disable
+          max: disable
+        sink:
+          - type: file
+            level:
+              min: fatal
+              max: debug
+            rotate:
+              number: 10
+              size: 10485760
+            file: "../log/etcd-test-node2.%N.log"
+            writing_alias: "../log/etcd-test-node2.log"
+            auto_flush: info
+            flush_interval: 1s
+          - type: stderr
+            level:
+              min: fatal
+              max: warning
+          - type: stdout
+            level:
+              min: fatal
+              max: debug

From 5ad70da3f39e762597f2ff137ebadcb9e58a6a6b Mon Sep 17 00:00:00 2001
From: yousongyang <yousongyang0105@gmail.com>
Date: Thu, 11 Jun 2026 11:47:30 +0800
Subject: [PATCH 05/12] =?UTF-8?q?ETCD=20=E4=B8=8E=20Discovery=20=E5=88=86?=
 =?UTF-8?q?=E7=A6=BB=20CR?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 include/atframe/modules/etcd_module.h         |   5 +-
 .../modules/service_discovery_module.h        |  11 +-
 src/atframe/modules/etcd_module.cpp           |  51 ++--
 .../modules/service_discovery_module.cpp      | 251 +++++++++---------
 test/case/atapp_etcd_module_test.cpp          |  34 +--
 5 files changed, 171 insertions(+), 181 deletions(-)

diff --git a/include/atframe/modules/etcd_module.h b/include/atframe/modules/etcd_module.h
index d1fcea2..7dcf10e 100644
--- a/include/atframe/modules/etcd_module.h
+++ b/include/atframe/modules/etcd_module.h
@@ -37,6 +37,7 @@ class etcd_module {
   LIBATAPP_MACRO_API void reset();
   LIBATAPP_MACRO_API int tick();
 
+  LIBATAPP_MACRO_API bool is_cluster_closing() const { return cluster_.check_flag(etcd_cluster::flag_t::kClosing); }
  public:
   LIBATAPP_MACRO_API atapp::etcd_cluster &get_etcd_cluster();
   LIBATAPP_MACRO_API const atapp::etcd_cluster &get_etcd_cluster() const;
@@ -56,7 +57,7 @@ class etcd_module {
                          const atapp::protocol::atapp_log *ATFW_UTIL_MACRO_NULLABLE log_conf = nullptr);
 
   bool enable_;
-  bool init_;
+  bool load_conf_;
   atfw::util::network::http_request::ptr_t cleanup_request_;
 
   atframework::atapp::app *ATFW_UTIL_MACRO_NULLABLE atapp_;
@@ -65,7 +66,5 @@ class etcd_module {
   // Config
   std::string conf_path_cache_;
   atapp::protocol::atapp_etcd conf_cache_;
-  atfw::util::time::time_utility::raw_time_t tick_next_timepoint_;
-  std::chrono::system_clock::duration tick_interval_;
 };
 LIBATAPP_MACRO_NAMESPACE_END
diff --git a/include/atframe/modules/service_discovery_module.h b/include/atframe/modules/service_discovery_module.h
index d339763..15f36cc 100644
--- a/include/atframe/modules/service_discovery_module.h
+++ b/include/atframe/modules/service_discovery_module.h
@@ -184,10 +184,8 @@ class service_discovery_module : public ::atframework::atapp::module_impl {
                                                                   const std::string &path);
 
   LIBATAPP_MACRO_API void reset_context_internal_watchers_and_keepalives();
-  LIBATAPP_MACRO_API int init_service_discovery_keepalives(
-      const ::atfw::util::nostd::nonnull<std::shared_ptr<service_discovery_cluster_context>> &context);
-  LIBATAPP_MACRO_API int init_service_discovery_watchers(
-      const ::atfw::util::nostd::nonnull<std::shared_ptr<service_discovery_cluster_context>> &context);
+  LIBATAPP_MACRO_API int init_service_discovery_keepalives_watchers(
+      const ::atfw::util::nostd::nonnull<std::shared_ptr<service_discovery_cluster_context>> &context, bool check_keepalive_actor_start_success = true);
 
   LIBATAPP_MACRO_API static int init_discovery_watcher_by_id(
       atframework::atapp::app &app,
@@ -300,6 +298,8 @@ class service_discovery_module : public ::atframework::atapp::module_impl {
 
  private:
   bool discovery_enabled_;
+  bool discovery_keepalives_watchers_inited_;
+
   ::atfw::util::nostd::nonnull<std::shared_ptr<service_discovery_cluster_context>> cluster_context_;
   std::list<::atfw::util::nostd::nonnull<std::shared_ptr<service_discovery_cluster_context>>>
       external_cluster_contexts_;
@@ -330,5 +330,8 @@ class service_discovery_module : public ::atframework::atapp::module_impl {
 
   mutable std::recursive_mutex topology_info_event_lock_;
   topology_info_event_callback_list_t topology_info_event_callbacks_;
+
+  atfw::util::time::time_utility::raw_time_t tick_next_timepoint_;
+  std::chrono::system_clock::duration tick_interval_;
 };
 LIBATAPP_MACRO_NAMESPACE_END
diff --git a/src/atframe/modules/etcd_module.cpp b/src/atframe/modules/etcd_module.cpp
index 106ad4a..a1c8c42 100644
--- a/src/atframe/modules/etcd_module.cpp
+++ b/src/atframe/modules/etcd_module.cpp
@@ -25,12 +25,12 @@
 #include <atframe/etcdcli/etcd_watcher.h>
 
 #include <algorithm>
+#include <list>
 #include <memory>
 #include <string>
 #include <unordered_map>
 #include <utility>
 #include <vector>
-#include <list>
 
 #if defined(max)
 #  undef max
@@ -80,26 +80,18 @@ static void init_timer_closed_callback(uv_handle_t *handle) {
 
 }  // namespace
 
-LIBATAPP_MACRO_API etcd_module::etcd_module()
-    : enable_(false),
-      init_(false),
-      atapp_(nullptr),
-      tick_interval_(std::chrono::duration_cast<std::chrono::system_clock::duration>(std::chrono::milliseconds(128))) {
-  tick_next_timepoint_ = app::get_sys_now();
-}
+LIBATAPP_MACRO_API etcd_module::etcd_module() : enable_(false), load_conf_(false), atapp_(nullptr) {}
 
 LIBATAPP_MACRO_API etcd_module::~etcd_module() { reset(); }
 
 LIBATAPP_MACRO_API int etcd_module::init(atframework::atapp::app &app, const atapp::protocol::atapp_etcd &conf,
                                          const atapp::protocol::atapp_log *ATFW_UTIL_MACRO_NULLABLE log_conf) {
-  init_ = true;
   atapp_ = &app;
   load_cluster_conf(conf, log_conf);
-  if (cluster_.get_conf_hosts().empty()) {
-    FWLOGINFO("cluster is disabled");
-  }
   if (is_etcd_enabled()) {
     cluster_.init(atapp_->get_shared_curl_multi_context());
+  } else {
+    FWLOGINFO("cluster is disabled");
   }
   return 0;
 }
@@ -109,10 +101,7 @@ LIBATAPP_MACRO_API int etcd_module::reload(const atapp::protocol::atapp_etcd &co
   if (atapp_ == nullptr) {
     return 0;
   }
-  // FIXME 现在不支持动态开关 etcd 功能
-  if (!init_ || is_etcd_enabled()) {
-    load_cluster_conf(conf, log_conf);
-  }
+  load_cluster_conf(conf, log_conf);
   return 0;
 }
 
@@ -260,14 +249,18 @@ LIBATAPP_MACRO_API int etcd_module::tick() {
     return 0;
   }
 
-  // Slow down the tick interval of etcd module, it require http request which is very slow compared to atbus
-  if (tick_next_timepoint_ >= atapp_->get_last_tick_time()) {
+  if (!is_etcd_enabled()) {
     return 0;
   }
-  tick_next_timepoint_ = atapp_->get_last_tick_time() + tick_interval_;
 
-  if (!is_etcd_enabled()) {
-    return 0;
+  // previous closing not finished, wait for it
+  if (cleanup_request_ || atapp_->is_closing()) {
+    return cluster_.tick();
+  }
+
+  // first startup when reloaded
+  if (cluster_.check_flag(etcd_cluster::flag_t::kClosing)) {
+    cluster_.init(atapp_->get_shared_curl_multi_context());
   }
 
   return cluster_.tick();
@@ -303,6 +296,15 @@ LIBATAPP_MACRO_API int etcd_module::stop() {
 
 void etcd_module::load_cluster_conf(const atapp::protocol::atapp_etcd &conf,
                                     const atapp::protocol::atapp_log *ATFW_UTIL_MACRO_NULLABLE log_conf) {
+  // 不支持动态关闭 etcd 功能
+  if (is_etcd_enabled() && (!conf.enable() || conf.hosts_size() == 0)) {
+    LIBATAPP_MACRO_ETCD_CLUSTER_LOG_WARNING(
+        cluster_,
+        "etcd cluster is disabled by new configure, but it's enabled by old configure, dynamic disable is not "
+        "supported, please restart app to apply the new configure.");
+    return;
+  }
+
   // load configure
   conf_cache_ = conf;
   enable_ = conf.enable();
@@ -480,13 +482,6 @@ void etcd_module::load_cluster_conf(const atapp::protocol::atapp_etcd &conf,
   if (!conf.ssl().ssl_cipher_list_tls13().empty()) {
     cluster_.set_conf_ssl_cipher_list_tls13(conf.ssl().ssl_cipher_list_tls13());
   }
-
-  tick_interval_ = std::chrono::duration_cast<std::chrono::system_clock::duration>(
-      std::chrono::seconds(conf.init().tick_interval().seconds()) +
-      std::chrono::nanoseconds(conf.init().tick_interval().nanos()));
-  if (tick_interval_ < std::chrono::duration_cast<std::chrono::system_clock::duration>(std::chrono::milliseconds(32))) {
-    tick_interval_ = std::chrono::duration_cast<std::chrono::system_clock::duration>(std::chrono::milliseconds(128));
-  }
 }
 
 LIBATAPP_MACRO_API std::string etcd_module::generate_etcd_path(const std::string &path) {
diff --git a/src/atframe/modules/service_discovery_module.cpp b/src/atframe/modules/service_discovery_module.cpp
index 4dcbc5f..7d3b66f 100644
--- a/src/atframe/modules/service_discovery_module.cpp
+++ b/src/atframe/modules/service_discovery_module.cpp
@@ -25,13 +25,13 @@
 #include <atframe/modules/etcd_module.h>
 
 #include <algorithm>
+#include <list>
 #include <memory>
 #include <set>
 #include <string>
 #include <unordered_map>
 #include <utility>
 #include <vector>
-#include <list>
 
 #if defined(max)
 #  undef max
@@ -218,11 +218,15 @@ struct ATFW_UTIL_SYMBOL_LOCAL service_discovery_module::service_discovery_cluste
 LIBATAPP_MACRO_API
 service_discovery_module::service_discovery_module()
     : discovery_enabled_(true),
+      discovery_keepalives_watchers_inited_(false),
       cluster_context_(std::make_shared<service_discovery_cluster_context>()),
       maybe_update_internal_keepalive_topology_value_(true),
       maybe_update_internal_keepalive_discovery_value_(true),
       maybe_update_internal_keepalive_discovery_area_(false),
-      maybe_update_internal_keepalive_discovery_metadata_(false) {}
+      maybe_update_internal_keepalive_discovery_metadata_(false),
+      tick_interval_(std::chrono::duration_cast<std::chrono::system_clock::duration>(std::chrono::milliseconds(128))) {
+  tick_next_timepoint_ = app::get_sys_now();
+}
 
 LIBATAPP_MACRO_API int service_discovery_module::init() {
   int ret = cluster_context_->init(*get_app(), get_app()->get_origin_configure().etcd(), nullptr);
@@ -231,56 +235,35 @@ LIBATAPP_MACRO_API int service_discovery_module::init() {
   }
 
   for (const auto &config : get_app()->get_origin_configure().external_discovery()) {
-    if (!config.enable()) {
-      continue;
-    }
     auto external_cluster_context = std::make_shared<service_discovery_cluster_context>();
     ret = external_cluster_context->init(*get_app(), config, nullptr);
     if (ret < 0) {
       return ret;
     }
+    if (!external_cluster_context->get_etcd_module().is_etcd_enabled()) {
+      continue;
+    }
     external_cluster_contexts_.push_back(std::move(external_cluster_context));
   }
 
-  if (!is_discovery_enabled()) {
+  if (!cluster_context_->get_etcd_module().is_etcd_enabled()) {
     return 0;
   }
 
-  ret = init_service_discovery_keepalives(cluster_context_);
+  ret = init_service_discovery_keepalives_watchers(cluster_context_);
   if (ret < 0) {
     stop();
     return ret;
   }
 
-  ret = init_service_discovery_watchers(cluster_context_);
-  if (ret < 0) {
-    stop();
-    return ret;
-  }
-
-  if (!cluster_context_->check_keepalive_actor_start_success()) {
-    stop();
-    return -1;
-  }
-
   for (const auto &external_cluster_context : external_cluster_contexts_) {
-    ret = init_service_discovery_keepalives(external_cluster_context);
-    if (ret < 0) {
-      stop();
-      return ret;
-    }
-
-    ret = init_service_discovery_watchers(external_cluster_context);
+    ret = init_service_discovery_keepalives_watchers(external_cluster_context);
     if (ret < 0) {
       stop();
       return ret;
     }
-
-    if (!external_cluster_context->check_keepalive_actor_start_success()) {
-      stop();
-      return -1;
-    }
   }
+  discovery_keepalives_watchers_inited_ = true;
 
   return 0;
 }
@@ -300,18 +283,60 @@ LIBATAPP_MACRO_API int service_discovery_module::stop() {
       ret = ext_ret;
     }
   }
+  discovery_keepalives_watchers_inited_ = false;
   return ret;
 }
 
 LIBATAPP_MACRO_API int service_discovery_module::reload() {
+  tick_interval_ = std::chrono::duration_cast<std::chrono::system_clock::duration>(
+      std::chrono::seconds(get_app()->get_origin_configure().etcd().init().tick_interval().seconds()) +
+      std::chrono::nanoseconds(get_app()->get_origin_configure().etcd().init().tick_interval().nanos()));
+  if (tick_interval_ < std::chrono::duration_cast<std::chrono::system_clock::duration>(std::chrono::milliseconds(32))) {
+    tick_interval_ = std::chrono::duration_cast<std::chrono::system_clock::duration>(std::chrono::milliseconds(128));
+  }
+
   // FIXME reload 不支持external cluster context的热更新，后续可以考虑增加这个功能
   return cluster_context_->reload(get_app()->get_origin_configure().etcd(), nullptr);
 }
 
 LIBATAPP_MACRO_API int service_discovery_module::tick() {
-  cluster_context_->tick();
+  // Slow down the tick interval of etcd module, it require http request which is very slow compared to atbus
+  if (tick_next_timepoint_ >= get_app()->get_last_tick_time()) {
+    return 0;
+  }
+  tick_next_timepoint_ = get_app()->get_last_tick_time() + tick_interval_;
+
+  bool discovery_keepalives_watchers_inited = discovery_keepalives_watchers_inited_;
+  {
+    cluster_context_->tick();
+    if (!cluster_context_->get_etcd_module().is_cluster_closing()) {
+      // 不是正在关闭状态
+      if (discovery_enabled_ && !discovery_keepalives_watchers_inited) {
+        init_service_discovery_keepalives_watchers(cluster_context_, false);
+        discovery_keepalives_watchers_inited_ = true;
+      }
+      if (!discovery_enabled_ && discovery_keepalives_watchers_inited) {
+        // 不是正在关闭状态但不需要 discovery 了
+        cluster_context_->reset_internal_watchers_and_keepalives();
+        discovery_keepalives_watchers_inited_ = false;
+      }
+    }
+  }
+
   for (const auto &external_cluster_context : external_cluster_contexts_) {
     external_cluster_context->tick();
+    if (!external_cluster_context->get_etcd_module().is_cluster_closing()) {
+      // 不是正在关闭状态
+      if (discovery_enabled_ && !discovery_keepalives_watchers_inited) {
+        init_service_discovery_keepalives_watchers(external_cluster_context, false);
+        discovery_keepalives_watchers_inited_ = true;
+      }
+      if (!discovery_enabled_ && discovery_keepalives_watchers_inited) {
+        // 不是正在关闭状态但不需要 discovery 了
+        external_cluster_context->reset_internal_watchers_and_keepalives();
+        discovery_keepalives_watchers_inited_ = false;
+      }
+    }
   }
 
   update_keepalive_topology_value();
@@ -339,39 +364,6 @@ LIBATAPP_MACRO_API void service_discovery_module::enable_discovery() {
     return;
   }
   discovery_enabled_ = true;
-  if (!is_discovery_enabled()) {
-    return;
-  }
-
-  int ret = init_service_discovery_keepalives(cluster_context_);
-  if (ret < 0) {
-    discovery_enabled_ = false;
-    reset_context_internal_watchers_and_keepalives();
-    return;
-  }
-
-  ret = init_service_discovery_watchers(cluster_context_);
-  if (ret < 0) {
-    discovery_enabled_ = false;
-    reset_context_internal_watchers_and_keepalives();
-    return;
-  }
-
-  for (const auto &external_cluster_context : external_cluster_contexts_) {
-    ret = init_service_discovery_keepalives(external_cluster_context);
-    if (ret < 0) {
-      discovery_enabled_ = false;
-      reset_context_internal_watchers_and_keepalives();
-      return;
-    }
-
-    ret = init_service_discovery_watchers(external_cluster_context);
-    if (ret < 0) {
-      discovery_enabled_ = false;
-      reset_context_internal_watchers_and_keepalives();
-      return;
-    }
-  }
 }
 
 LIBATAPP_MACRO_API void service_discovery_module::disable_discovery() {
@@ -379,7 +371,6 @@ LIBATAPP_MACRO_API void service_discovery_module::disable_discovery() {
     return;
   }
   discovery_enabled_ = false;
-  reset_context_internal_watchers_and_keepalives();
 }
 
 LIBATAPP_MACRO_API void service_discovery_module::reset_context_internal_watchers_and_keepalives() {
@@ -387,6 +378,7 @@ LIBATAPP_MACRO_API void service_discovery_module::reset_context_internal_watcher
   for (const auto &external_cluster_context : external_cluster_contexts_) {
     external_cluster_context->reset_internal_watchers_and_keepalives();
   }
+  discovery_keepalives_watchers_inited_ = false;
 }
 
 void service_discovery_module::update_keepalive_topology_value() {
@@ -416,6 +408,15 @@ void service_discovery_module::update_keepalive_topology_value() {
         (*iter)->set_value(internal_keepalive_topology_value_);
       }
     }
+    for (const auto &external_cluster_context : external_cluster_contexts_) {
+      for (std::list<etcd_keepalive::ptr_t>::iterator iter =
+               external_cluster_context->data_->internal_topology_keepalive_actors_.begin();
+           iter != external_cluster_context->data_->internal_topology_keepalive_actors_.end(); ++iter) {
+        if (*iter) {
+          (*iter)->set_value(internal_keepalive_topology_value_);
+        }
+      }
+    }
   }
 }
 
@@ -463,59 +464,63 @@ void service_discovery_module::update_keepalive_discovery_value() {
         (*iter)->set_value(internal_keepalive_discovery_value_);
       }
     }
+    for (const auto &external_cluster_context : external_cluster_contexts_) {
+      for (std::list<etcd_keepalive::ptr_t>::iterator iter =
+               external_cluster_context->data_->internal_discovery_keepalive_actors_.begin();
+           iter != external_cluster_context->data_->internal_discovery_keepalive_actors_.end(); ++iter) {
+        if (*iter) {
+          (*iter)->set_value(internal_keepalive_discovery_value_);
+        }
+      }
+    }
   }
 }
 
-LIBATAPP_MACRO_API int service_discovery_module::init_service_discovery_keepalives(
-    const ::atfw::util::nostd::nonnull<std::shared_ptr<service_discovery_cluster_context>> &context) {
+LIBATAPP_MACRO_API int service_discovery_module::init_service_discovery_keepalives_watchers(
+    const ::atfw::util::nostd::nonnull<std::shared_ptr<service_discovery_cluster_context>> &context,
+    bool check_keepalive_actor_start_success) {
   // 先刷新topology数据，后刷新discovery数据，以保证策略路由变化时已获取到最新的topology信息
   update_keepalive_topology_value();
   update_keepalive_discovery_value();
 
-  atframework::atapp::app &app = *get_app();
+  int ret = 0;
 
+  atframework::atapp::app &app = *get_app();
   if (context->get_etcd_module().get_configure().keepalive().enabled()) {
-    int ret = init_topology_keepalive(app, context, internal_keepalive_topology_value_);
-    if (ret < 0) {
-      return ret;
+    int result = init_topology_keepalive(app, context, internal_keepalive_topology_value_);
+    if (result < 0) {
+      ret = result;
     }
-    ret = init_discovery_keepalive_by_id(app, context, internal_keepalive_discovery_value_);
-    if (ret < 0) {
-      return ret;
+    result = init_discovery_keepalive_by_id(app, context, internal_keepalive_discovery_value_);
+    if (result < 0) {
+      ret = result;
     }
-    ret = init_discovery_keepalive_by_name(app, context, internal_keepalive_discovery_value_);
-    if (ret < 0) {
-      return ret;
+    result = init_discovery_keepalive_by_name(app, context, internal_keepalive_discovery_value_);
+    if (result < 0) {
+      ret = result;
     }
   }
 
-  return 0;
-}
-
-LIBATAPP_MACRO_API int service_discovery_module::init_service_discovery_watchers(
-    const ::atfw::util::nostd::nonnull<std::shared_ptr<service_discovery_cluster_context>> &context) {
-  // 先刷新topology数据，后刷新discovery数据，以保证策略路由变化时已获取到最新的topology信息
-  update_keepalive_topology_value();
-  update_keepalive_discovery_value();
-
-  atframework::atapp::app &app = *get_app();
-
   if (context->get_etcd_module().get_configure().watcher().enabled()) {
-    int ret = add_topology_watcher_callback(app, context, nullptr);
-    if (ret < 0) {
-      return ret;
+    int result = add_topology_watcher_callback(app, context, nullptr);
+    if (result < 0) {
+      ret = result;
     }
-    ret = add_discovery_watcher_by_id_callback(app, context, nullptr);
-    if (ret < 0) {
-      return ret;
+    result = add_discovery_watcher_by_id_callback(app, context, nullptr);
+    if (result < 0) {
+      ret = result;
     }
-    ret = add_discovery_watcher_by_name_callback(app, context, nullptr);
-    if (ret < 0) {
-      return ret;
+    result = add_discovery_watcher_by_name_callback(app, context, nullptr);
+    if (result < 0) {
+      ret = result;
     }
   }
 
-  return 0;
+  if (ret == 0 && check_keepalive_actor_start_success && !context->check_keepalive_actor_start_success()) {
+    return -1;
+  }
+
+  return ret;
 }
 
 LIBATAPP_MACRO_API int service_discovery_module::init_discovery_keepalive_by_id(
@@ -1554,39 +1559,43 @@ bool service_discovery_module::update_internal_watcher_event(node_info_t &node,
     }
   } else {
     if (node_action_t::kDelete == node.action) {
-      if (local_cache_by_id) {
-        if (local_cache_by_id->get_context_addr() != node.context_addr) {
-          // 只有相同 context 才进行处理
-          LIBATAPP_MACRO_ETCD_CLUSTER_LOG_WARNING(
-              cluster_context_->etcd_module_.get_etcd_cluster(),
-              "try to delete node with same id but different context, ignore it. node id: {}, node name: {}, node "
-              "context: {}, local cache context: {}",
-              node.node_discovery.id(), node.node_discovery.name().c_str(), reinterpret_cast<void *>(node.context_addr),
-              reinterpret_cast<void *>(local_cache_by_id->get_context_addr()));
-          local_cache_by_id = nullptr;
-        } else {
+      // 有一个节点 context 匹配则都删除
+      // 都不匹配则无视
+      if ((local_cache_by_id && local_cache_by_id->get_context_addr() == node.context_addr) ||
+          (local_cache_by_name && local_cache_by_name->get_context_addr() == node.context_addr)) {
+        if (local_cache_by_id) {
+          if (local_cache_by_id->get_context_addr() != node.context_addr) {
+            // 只有相同 context 才进行处理
+            LIBATAPP_MACRO_ETCD_CLUSTER_LOG_WARNING(
+                cluster_context_->etcd_module_.get_etcd_cluster(),
+                "try to delete node with same id but different context. node id: {}, node name: {}, node "
+                "context: {}, local cache context: {}",
+                node.node_discovery.id(), node.node_discovery.name().c_str(),
+                reinterpret_cast<void *>(node.context_addr),
+                reinterpret_cast<void *>(local_cache_by_id->get_context_addr()));
+          }
           local_cache_by_id->update_version(version, true);
           global_discovery_.remove_node(local_cache_by_id);
           has_event = true;
         }
-      }
-      if (local_cache_by_name) {
-        if (local_cache_by_name->get_context_addr() != node.context_addr) {
-          // 只有相同 context 才进行处理
-          LIBATAPP_MACRO_ETCD_CLUSTER_LOG_WARNING(
-              cluster_context_->etcd_module_.get_etcd_cluster(),
-              "try to delete node with same name but different context, ignore it. node id: {}, node name: {}, node "
-              "context: {}, local cache context: {}",
-              node.node_discovery.id(), node.node_discovery.name().c_str(), reinterpret_cast<void *>(node.context_addr),
-              reinterpret_cast<void *>(local_cache_by_name->get_context_addr()));
-          local_cache_by_name = nullptr;
-        } else {
+        if (local_cache_by_name) {
+          if (local_cache_by_name->get_context_addr() != node.context_addr) {
+            // 只有相同 context 才进行处理
+            LIBATAPP_MACRO_ETCD_CLUSTER_LOG_WARNING(
+                cluster_context_->etcd_module_.get_etcd_cluster(),
+                "try to delete node with same name but different context. node id: {}, node name: {}, node "
+                "context: {}, local cache context: {}",
+                node.node_discovery.id(), node.node_discovery.name().c_str(),
+                reinterpret_cast<void *>(node.context_addr),
+                reinterpret_cast<void *>(local_cache_by_name->get_context_addr()));
+          }
           local_cache_by_name->update_version(version, true);
           global_discovery_.remove_node(local_cache_by_name);
           has_event = true;
         }
       }
     } else {
+      // 有一个匹配或都不存在则更新/添加
       if ((!local_cache_by_id && 0 != node.node_discovery.id()) ||
           (!local_cache_by_name && !node.node_discovery.name().empty())) {
         has_event = true;
diff --git a/test/case/atapp_etcd_module_test.cpp b/test/case/atapp_etcd_module_test.cpp
index 38ff368..7738d59 100644
--- a/test/case/atapp_etcd_module_test.cpp
+++ b/test/case/atapp_etcd_module_test.cpp
@@ -1722,21 +1722,11 @@ CASE_TEST(atapp_etcd_module, multi_context_snapshot_isolation) {
       return;
     }
 
-    ret = discovery1->init_service_discovery_keepalives(service_discovery_context);
+    ret = discovery1->init_service_discovery_keepalives_watchers(service_discovery_context);
     CASE_EXPECT_TRUE(ret == 0);
     if (ret != 0) {
       return;
     }
-    ret = discovery1->init_service_discovery_watchers(service_discovery_context);
-    CASE_EXPECT_TRUE(ret == 0);
-    if (ret != 0) {
-      return;
-    }
-    bool success = service_discovery_context->check_keepalive_actor_start_success();
-    CASE_EXPECT_TRUE(success);
-    if (!success) {
-      return;
-    }
 
     // Phase 5: 等待发现app3
     apps = {&app1, &app3};
@@ -1811,41 +1801,35 @@ CASE_TEST(atapp_etcd_module, diff_context_snapshot_isolation) {
 
   auto service_discovery_context_a =
       std::make_shared<atframework::atapp::service_discovery_module::service_discovery_cluster_context>();
-  int ret = service_discovery_context_a->init(app1, discovery2->get_configure(), nullptr);
+  auto context_a_conf = discovery2->get_configure();
+  context_a_conf.mutable_keepalive()->set_enabled(false);  // 禁止keepalive以避免覆盖app2的snapshot
+  int ret = service_discovery_context_a->init(app1, context_a_conf, nullptr);
   CASE_EXPECT_TRUE(ret == 0);
   if (ret != 0) {
     return;
   }
 
-  ret = discovery1->init_service_discovery_watchers(service_discovery_context_a);
+  ret = discovery1->init_service_discovery_keepalives_watchers(service_discovery_context_a);
   CASE_EXPECT_TRUE(ret == 0);
   if (ret != 0) {
     return;
   }
-  bool success = service_discovery_context_a->check_keepalive_actor_start_success();
-  CASE_EXPECT_TRUE(success);
-  if (!success) {
-    return;
-  }
 
   auto service_discovery_context_b =
       std::make_shared<atframework::atapp::service_discovery_module::service_discovery_cluster_context>();
-  ret = service_discovery_context_b->init(app1, discovery3->get_configure(), nullptr);
+  auto context_b_conf = discovery3->get_configure();
+  context_b_conf.mutable_keepalive()->set_enabled(false);  // 禁止keepalive以避免覆盖app3的snapshot
+  ret = service_discovery_context_b->init(app1, context_b_conf, nullptr);
   CASE_EXPECT_TRUE(ret == 0);
   if (ret != 0) {
     return;
   }
 
-  ret = discovery1->init_service_discovery_watchers(service_discovery_context_b);
+  ret = discovery1->init_service_discovery_keepalives_watchers(service_discovery_context_b);
   CASE_EXPECT_TRUE(ret == 0);
   if (ret != 0) {
     return;
   }
-  success = service_discovery_context_b->check_keepalive_actor_start_success();
-  CASE_EXPECT_TRUE(success);
-  if (!success) {
-    return;
-  }
 
   // Phase 5: 等待发现并检查是否为app2的listener地址（如果app3覆盖了app2的snapshot，则会看到app3的地址）
   std::vector<atframework::atapp::app *> apps = {&app1, &app2, &app3};

From 242dfa656f942fb8e5a3644336e4d1986e2ec684 Mon Sep 17 00:00:00 2001
From: yousongyang <yousongyang0105@gmail.com>
Date: Thu, 11 Jun 2026 11:52:01 +0800
Subject: [PATCH 06/12] =?UTF-8?q?ETCD=20=E4=B8=8E=20Discovery=20=E5=88=86?=
 =?UTF-8?q?=E7=A6=BB=20=E4=BF=AE=E6=AD=A3=E7=BC=96=E8=AF=91?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 include/atframe/modules/etcd_module.h | 1 -
 src/atframe/modules/etcd_module.cpp   | 2 +-
 2 files changed, 1 insertion(+), 2 deletions(-)

diff --git a/include/atframe/modules/etcd_module.h b/include/atframe/modules/etcd_module.h
index 7dcf10e..ca3e88c 100644
--- a/include/atframe/modules/etcd_module.h
+++ b/include/atframe/modules/etcd_module.h
@@ -57,7 +57,6 @@ class etcd_module {
                          const atapp::protocol::atapp_log *ATFW_UTIL_MACRO_NULLABLE log_conf = nullptr);
 
   bool enable_;
-  bool load_conf_;
   atfw::util::network::http_request::ptr_t cleanup_request_;
 
   atframework::atapp::app *ATFW_UTIL_MACRO_NULLABLE atapp_;
diff --git a/src/atframe/modules/etcd_module.cpp b/src/atframe/modules/etcd_module.cpp
index a1c8c42..4ced56f 100644
--- a/src/atframe/modules/etcd_module.cpp
+++ b/src/atframe/modules/etcd_module.cpp
@@ -80,7 +80,7 @@ static void init_timer_closed_callback(uv_handle_t *handle) {
 
 }  // namespace
 
-LIBATAPP_MACRO_API etcd_module::etcd_module() : enable_(false), load_conf_(false), atapp_(nullptr) {}
+LIBATAPP_MACRO_API etcd_module::etcd_module() : enable_(false), atapp_(nullptr) {}
 
 LIBATAPP_MACRO_API etcd_module::~etcd_module() { reset(); }
 

From ab5f05822ed5fee87aada07332e7452c97d4262e Mon Sep 17 00:00:00 2001
From: yousongyang <yousongyang0105@gmail.com>
Date: Thu, 11 Jun 2026 11:55:36 +0800
Subject: [PATCH 07/12] =?UTF-8?q?ETCD=20=E4=B8=8E=20Discovery=20=E5=88=86?=
 =?UTF-8?q?=E7=A6=BB=20CR?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 src/atframe/atapp.cpp | 2 --
 1 file changed, 2 deletions(-)

diff --git a/src/atframe/atapp.cpp b/src/atframe/atapp.cpp
index 773fe74..a69c619 100644
--- a/src/atframe/atapp.cpp
+++ b/src/atframe/atapp.cpp
@@ -564,7 +564,6 @@ LIBATAPP_MACRO_API app::~app() {
   if (curl_multi_) {
     atfw::util::network::http_request::destroy_curl_multi(curl_multi_);
   }
-  curl_multi_guard_ = nullptr;
 
   // finally events
   app_evt_on_finally();
@@ -4155,7 +4154,6 @@ int app::setup_curl_multi() {
   atfw::util::network::http_request::create_curl_multi(get_bus_node()->get_evloop(), curl_multi_);
   if (!curl_multi_) {
     FWLOGERROR("create curl multi instance failed.");
-    curl_multi_guard_ = nullptr;
     return -1;
   }
   return 0;

From cf7a2a437943a5151c52d38eefc84197053b2961 Mon Sep 17 00:00:00 2001
From: yousongyang <yousongyang0105@gmail.com>
Date: Thu, 11 Jun 2026 11:57:46 +0800
Subject: [PATCH 08/12] =?UTF-8?q?ETCD=20=E4=B8=8E=20Discovery=20=E5=88=86?=
 =?UTF-8?q?=E7=A6=BB=20CR?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 src/atframe/modules/service_discovery_module.cpp | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/atframe/modules/service_discovery_module.cpp b/src/atframe/modules/service_discovery_module.cpp
index 7d3b66f..643b432 100644
--- a/src/atframe/modules/service_discovery_module.cpp
+++ b/src/atframe/modules/service_discovery_module.cpp
@@ -1279,10 +1279,10 @@ void service_discovery_module::discovery_watcher_callback_list_wrapper_t::operat
   if (nullptr == mod) {
     return;
   }
-  if (ctx.expired()) {
+  auto ctx_locked = ctx.lock();
+  if (ctx_locked == nullptr) {
     return;
   }
-  auto ctx_locked = ctx.lock();
   ctx_locked->data_->last_etcd_event_discovery_header_ = header;
 
   bool enable_snapshot = body.snapshot && 0 != snapshot_index;
@@ -1410,10 +1410,10 @@ void service_discovery_module::topology_watcher_callback_list_wrapper_t::operato
   if (nullptr == mod) {
     return;
   }
-  if (ctx.expired()) {
+  auto ctx_locked = ctx.lock();
+  if (ctx_locked == nullptr) {
     return;
   }
-  auto ctx_locked = ctx.lock();
   ctx_locked->data_->last_etcd_event_topology_header_ = header;
 
   bool enable_snapshot = body.snapshot && 0 != snapshot_index;

From 41de10d15668898f526c60ae282f0eea5810fa46 Mon Sep 17 00:00:00 2001
From: yousongyang <yousongyang0105@gmail.com>
Date: Thu, 11 Jun 2026 12:46:36 +0800
Subject: [PATCH 09/12] =?UTF-8?q?ETCD=20=E4=B8=8E=20Discovery=20=E5=88=86?=
 =?UTF-8?q?=E7=A6=BB=20CR?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 src/atframe/modules/service_discovery_module.cpp | 12 +++++++-----
 1 file changed, 7 insertions(+), 5 deletions(-)

diff --git a/src/atframe/modules/service_discovery_module.cpp b/src/atframe/modules/service_discovery_module.cpp
index 643b432..8508453 100644
--- a/src/atframe/modules/service_discovery_module.cpp
+++ b/src/atframe/modules/service_discovery_module.cpp
@@ -1268,8 +1268,9 @@ service_discovery_module::discovery_watcher_callback_list_wrapper_t::discovery_w
       has_insert_snapshot_index(false) {}
 
 service_discovery_module::discovery_watcher_callback_list_wrapper_t::~discovery_watcher_callback_list_wrapper_t() {
-  if (!ctx.expired() && 0 != snapshot_index && has_insert_snapshot_index) {
-    ctx.lock()->data_->discovery_watcher_snapshot_index_.erase(snapshot_index);
+  auto ctx_locked = ctx.lock();
+  if (ctx_locked && 0 != snapshot_index && has_insert_snapshot_index) {
+    ctx_locked->data_->discovery_watcher_snapshot_index_.erase(snapshot_index);
   }
 }
 
@@ -1399,8 +1400,9 @@ service_discovery_module::topology_watcher_callback_list_wrapper_t::topology_wat
       has_insert_snapshot_index(false) {}
 
 service_discovery_module::topology_watcher_callback_list_wrapper_t::~topology_watcher_callback_list_wrapper_t() {
-  if (!ctx.expired() && 0 != snapshot_index && has_insert_snapshot_index) {
-    ctx.lock()->data_->topology_watcher_snapshot_index_.erase(snapshot_index);
+  auto ctx_locked = ctx.lock();
+  if (ctx_locked && 0 != snapshot_index && has_insert_snapshot_index) {
+    ctx_locked->data_->topology_watcher_snapshot_index_.erase(snapshot_index);
   }
 }
 
@@ -1534,7 +1536,7 @@ bool service_discovery_module::update_internal_watcher_event(node_info_t &node,
           // 只有相同 context 才进行处理
           LIBATAPP_MACRO_ETCD_CLUSTER_LOG_WARNING(
               cluster_context_->etcd_module_.get_etcd_cluster(),
-              "try to delete node with same id but different context, ignore it. node id: {}, node name: {}, node "
+              "try to update node with same id but different context, ignore it. node id: {}, node name: {}, node "
               "context: {}, local cache context: {}",
               node.node_discovery.id(), node.node_discovery.name().c_str(), reinterpret_cast<void *>(node.context_addr),
               reinterpret_cast<void *>(local_cache_by_id->get_context_addr()));

From 355afb2da37a17bf1d84717334a92fe6225cbe58 Mon Sep 17 00:00:00 2001
From: yousongyang <yousongyang0105@gmail.com>
Date: Wed, 17 Jun 2026 10:23:19 +0800
Subject: [PATCH 10/12] =?UTF-8?q?ETCD=20=E4=B8=8E=20Discovery=20=E5=88=86?=
 =?UTF-8?q?=E7=A6=BB=20CR?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 src/atframe/atapp.cpp                         | 16 ++++++-------
 src/atframe/modules/etcd_module.cpp           |  2 +-
 .../modules/service_discovery_module.cpp      | 24 +++++++++++--------
 3 files changed, 23 insertions(+), 19 deletions(-)

diff --git a/src/atframe/atapp.cpp b/src/atframe/atapp.cpp
index a69c619..3706907 100644
--- a/src/atframe/atapp.cpp
+++ b/src/atframe/atapp.cpp
@@ -4151,7 +4151,7 @@ int app::setup_curl_multi() {
   multi_options.ev_loop = get_bus_node()->get_evloop();
   // Share DNS cache, connection, TLS sessions and etc.
   atfw::util::network::http_request::create_curl_share(share_options, multi_options.share_context);
-  atfw::util::network::http_request::create_curl_multi(get_bus_node()->get_evloop(), curl_multi_);
+  atfw::util::network::http_request::create_curl_multi(multi_options, curl_multi_);
   if (!curl_multi_) {
     FWLOGERROR("create curl multi instance failed.");
     return -1;
@@ -4864,16 +4864,16 @@ int app::command_handler_invalid(atfw::util::cli::callback_param params) {
 
 int app::command_handler_disable_discovery(atfw::util::cli::callback_param params) {
   if (!internal_module_service_discovery_) {
-    const char *msg = "Etcd module is not initialized, skip command.";
+    const char *msg = "Service discovery module not initialized, skip command.";
     FWLOGERROR("{}", msg);
     add_custom_command_rsp(params, msg);
   } else if (internal_module_service_discovery_->is_discovery_enabled()) {
     internal_module_service_discovery_->disable_discovery();
-    const char *msg = "Etcd context is disabled now.";
+    const char *msg = "Service discovery context is disabled now.";
     FWLOGINFO("{}", msg);
     add_custom_command_rsp(params, msg);
   } else {
-    const char *msg = "Etcd context is already disabled, skip command.";
+    const char *msg = "Service discovery context is already disabled, skip command.";
     FWLOGERROR("{}", msg);
     add_custom_command_rsp(params, msg);
   }
@@ -4882,21 +4882,21 @@ int app::command_handler_disable_discovery(atfw::util::cli::callback_param param
 
 int app::command_handler_enable_discovery(atfw::util::cli::callback_param params) {
   if (!internal_module_service_discovery_) {
-    const char *msg = "Etcd module not initialized, skip command.";
+    const char *msg = "Service discovery module not initialized, skip command.";
     FWLOGERROR("{}", msg);
     add_custom_command_rsp(params, msg);
   } else if (internal_module_service_discovery_->is_discovery_enabled()) {
-    const char *msg = "Etcd context is already enabled, skip command.";
+    const char *msg = "Service discovery context is already enabled, skip command.";
     FWLOGERROR("{}", msg);
     add_custom_command_rsp(params, msg);
   } else {
     internal_module_service_discovery_->enable_discovery();
     if (internal_module_service_discovery_->is_discovery_enabled()) {
-      const char *msg = "Etcd context is enabled now.";
+      const char *msg = "Service discovery context is enabled now.";
       FWLOGINFO("{}", msg);
       add_custom_command_rsp(params, msg);
     } else {
-      const char *msg = "Etcd context can not be enabled, maybe need configure etcd.hosts.";
+      const char *msg = "Service discovery context can not be enabled, maybe need configure etcd.hosts.";
       FWLOGERROR("{}", msg);
       add_custom_command_rsp(params, msg);
     }
diff --git a/src/atframe/modules/etcd_module.cpp b/src/atframe/modules/etcd_module.cpp
index 4ced56f..ac381e9 100644
--- a/src/atframe/modules/etcd_module.cpp
+++ b/src/atframe/modules/etcd_module.cpp
@@ -504,7 +504,7 @@ int etcd_module::http_callback_on_etcd_closed(atfw::util::network::http_request
     return 0;
   }
 
-  self->reset();
+  self->cleanup_request_.reset();
   LIBATAPP_MACRO_ETCD_CLUSTER_LOG_DEBUG(self->cluster_, "Etcd revoke lease finished");
 
   if (self->atapp_ != nullptr) {
diff --git a/src/atframe/modules/service_discovery_module.cpp b/src/atframe/modules/service_discovery_module.cpp
index 8508453..a396425 100644
--- a/src/atframe/modules/service_discovery_module.cpp
+++ b/src/atframe/modules/service_discovery_module.cpp
@@ -1521,8 +1521,9 @@ bool service_discovery_module::update_internal_watcher_event(node_info_t &node,
               cluster_context_->etcd_module_.get_etcd_cluster(),
               "try to delete node with same id but different context, ignore it. node id: {}, node name: {}, node "
               "context: {}, local cache context: {}",
-              node.node_discovery.id(), node.node_discovery.name().c_str(), reinterpret_cast<void *>(node.context_addr),
-              reinterpret_cast<void *>(local_cache_by_id->get_context_addr()));
+              node.node_discovery.id(), node.node_discovery.name().c_str(),
+              reinterpret_cast<void *>(node.context_addr),                       // NOLINT(performance-no-int-to-ptr)
+              reinterpret_cast<void *>(local_cache_by_id->get_context_addr()));  // NOLINT(performance-no-int-to-ptr)
           return false;
         }
         local_cache_by_id->update_version(version, true);
@@ -1538,8 +1539,9 @@ bool service_discovery_module::update_internal_watcher_event(node_info_t &node,
               cluster_context_->etcd_module_.get_etcd_cluster(),
               "try to update node with same id but different context, ignore it. node id: {}, node name: {}, node "
               "context: {}, local cache context: {}",
-              node.node_discovery.id(), node.node_discovery.name().c_str(), reinterpret_cast<void *>(node.context_addr),
-              reinterpret_cast<void *>(local_cache_by_id->get_context_addr()));
+              node.node_discovery.id(), node.node_discovery.name().c_str(),
+              reinterpret_cast<void *>(node.context_addr),                       // NOLINT(performance-no-int-to-ptr)
+              reinterpret_cast<void *>(local_cache_by_id->get_context_addr()));  // NOLINT(performance-no-int-to-ptr)
           return false;
         }
         if (protobuf_equal(local_cache_by_id->get_discovery_info(), node.node_discovery)) {
@@ -1573,8 +1575,8 @@ bool service_discovery_module::update_internal_watcher_event(node_info_t &node,
                 "try to delete node with same id but different context. node id: {}, node name: {}, node "
                 "context: {}, local cache context: {}",
                 node.node_discovery.id(), node.node_discovery.name().c_str(),
-                reinterpret_cast<void *>(node.context_addr),
-                reinterpret_cast<void *>(local_cache_by_id->get_context_addr()));
+                reinterpret_cast<void *>(node.context_addr),                       // NOLINT(performance-no-int-to-ptr)
+                reinterpret_cast<void *>(local_cache_by_id->get_context_addr()));  // NOLINT(performance-no-int-to-ptr)
           }
           local_cache_by_id->update_version(version, true);
           global_discovery_.remove_node(local_cache_by_id);
@@ -1588,8 +1590,9 @@ bool service_discovery_module::update_internal_watcher_event(node_info_t &node,
                 "try to delete node with same name but different context. node id: {}, node name: {}, node "
                 "context: {}, local cache context: {}",
                 node.node_discovery.id(), node.node_discovery.name().c_str(),
-                reinterpret_cast<void *>(node.context_addr),
-                reinterpret_cast<void *>(local_cache_by_name->get_context_addr()));
+                reinterpret_cast<void *>(node.context_addr),  // NOLINT(performance-no-int-to-ptr)
+                reinterpret_cast<void *>(
+                    local_cache_by_name->get_context_addr()));  // NOLINT(performance-no-int-to-ptr)
           }
           local_cache_by_name->update_version(version, true);
           global_discovery_.remove_node(local_cache_by_name);
@@ -1707,8 +1710,9 @@ bool service_discovery_module::update_internal_watcher_event(topology_info_t &to
         LIBATAPP_MACRO_ETCD_CLUSTER_LOG_WARNING(
             cluster_context_->etcd_module_.get_etcd_cluster(),
             "Received topology event with id {} from context {}, but current context is {}, ignore it",
-            topology_info.storage.info->id(), (void *)topology_info.storage.context_addr,
-            (void *)local_cache_iter->second.context_addr);
+            topology_info.storage.info->id(),
+            reinterpret_cast<void *>(topology_info.storage.context_addr),      // NOLINT(performance-no-int-to-ptr)
+            reinterpret_cast<void *>(local_cache_iter->second.context_addr));  // NOLINT(performance-no-int-to-ptr)
         return false;
       }
 

From 3f40e6bbe4453c004415f22e3cea1899bd108806 Mon Sep 17 00:00:00 2001
From: yousongyang <yousongyang0105@gmail.com>
Date: Wed, 17 Jun 2026 15:41:53 +0800
Subject: [PATCH 11/12] =?UTF-8?q?ETCD=20=E4=B8=8E=20Discovery=20=E5=88=86?=
 =?UTF-8?q?=E7=A6=BB=20CR?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../modules/service_discovery_module.cpp      | 28 ++++++++++---------
 1 file changed, 15 insertions(+), 13 deletions(-)

diff --git a/src/atframe/modules/service_discovery_module.cpp b/src/atframe/modules/service_discovery_module.cpp
index a396425..7675f3f 100644
--- a/src/atframe/modules/service_discovery_module.cpp
+++ b/src/atframe/modules/service_discovery_module.cpp
@@ -238,6 +238,7 @@ LIBATAPP_MACRO_API int service_discovery_module::init() {
     auto external_cluster_context = std::make_shared<service_discovery_cluster_context>();
     ret = external_cluster_context->init(*get_app(), config, nullptr);
     if (ret < 0) {
+      stop();
       return ret;
     }
     if (!external_cluster_context->get_etcd_module().is_etcd_enabled()) {
@@ -276,13 +277,22 @@ LIBATAPP_MACRO_API service_discovery_module::service_discovery_cluster_context::
     : data_(std::make_shared<service_discovery_cluster_context_data>()) {}
 
 LIBATAPP_MACRO_API int service_discovery_module::stop() {
-  int ret = cluster_context_->stop();
-  for (const auto &external_cluster_context : external_cluster_contexts_) {
-    int ext_ret = external_cluster_context->stop();
+  int ret = 0;
+  // 逆序Stop
+  for (auto iter = external_cluster_contexts_.rbegin(); iter != external_cluster_contexts_.rend(); ++iter) {
+    int ext_ret = (*iter)->stop();
     if (ext_ret != 0) {
       ret = ext_ret;
+    } else {
+      (*iter)->reset();
     }
   }
+  int ext_ret = cluster_context_->stop();
+  if (ext_ret != 0) {
+    ret = ext_ret;
+  } else {
+    cluster_context_->reset();
+  }
   discovery_keepalives_watchers_inited_ = false;
   return ret;
 }
@@ -373,14 +383,6 @@ LIBATAPP_MACRO_API void service_discovery_module::disable_discovery() {
   discovery_enabled_ = false;
 }
 
-LIBATAPP_MACRO_API void service_discovery_module::reset_context_internal_watchers_and_keepalives() {
-  cluster_context_->reset_internal_watchers_and_keepalives();
-  for (const auto &external_cluster_context : external_cluster_contexts_) {
-    external_cluster_context->reset_internal_watchers_and_keepalives();
-  }
-  discovery_keepalives_watchers_inited_ = false;
-}
-
 void service_discovery_module::update_keepalive_topology_value() {
   if (!maybe_update_internal_keepalive_topology_value_ || nullptr == get_app()) {
     return;
@@ -1590,8 +1592,8 @@ bool service_discovery_module::update_internal_watcher_event(node_info_t &node,
                 "try to delete node with same name but different context. node id: {}, node name: {}, node "
                 "context: {}, local cache context: {}",
                 node.node_discovery.id(), node.node_discovery.name().c_str(),
-                reinterpret_cast<void *>(node.context_addr),  // NOLINT(performance-no-int-to-ptr)
-                reinterpret_cast<void *>(
+                reinterpret_cast<void *>(node.context_addr),    // NOLINT(performance-no-int-to-ptr)
+                reinterpret_cast<void *>(                       // NOLINT(performance-no-int-to-ptr)
                     local_cache_by_name->get_context_addr()));  // NOLINT(performance-no-int-to-ptr)
           }
           local_cache_by_name->update_version(version, true);

From 273a977d9a281127ff608bea1895edc811cfe5d0 Mon Sep 17 00:00:00 2001
From: yousongyang <yousongyang0105@gmail.com>
Date: Wed, 17 Jun 2026 17:21:29 +0800
Subject: [PATCH 12/12] =?UTF-8?q?ETCD=20=E4=B8=8E=20Discovery=20=E5=88=86?=
 =?UTF-8?q?=E7=A6=BB=20CR?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 include/atframe/modules/etcd_module.h            |  3 +++
 src/atframe/modules/etcd_module.cpp              |  7 +++++--
 src/atframe/modules/service_discovery_module.cpp | 10 ++++++----
 3 files changed, 14 insertions(+), 6 deletions(-)

diff --git a/include/atframe/modules/etcd_module.h b/include/atframe/modules/etcd_module.h
index ca3e88c..7922f28 100644
--- a/include/atframe/modules/etcd_module.h
+++ b/include/atframe/modules/etcd_module.h
@@ -38,6 +38,8 @@ class etcd_module {
   LIBATAPP_MACRO_API int tick();
 
   LIBATAPP_MACRO_API bool is_cluster_closing() const { return cluster_.check_flag(etcd_cluster::flag_t::kClosing); }
+  LIBATAPP_MACRO_API bool is_cluster_init() const { return cluster_init_; }
+
  public:
   LIBATAPP_MACRO_API atapp::etcd_cluster &get_etcd_cluster();
   LIBATAPP_MACRO_API const atapp::etcd_cluster &get_etcd_cluster() const;
@@ -60,6 +62,7 @@ class etcd_module {
   atfw::util::network::http_request::ptr_t cleanup_request_;
 
   atframework::atapp::app *ATFW_UTIL_MACRO_NULLABLE atapp_;
+  bool cluster_init_;
   atapp::etcd_cluster cluster_;
 
   // Config
diff --git a/src/atframe/modules/etcd_module.cpp b/src/atframe/modules/etcd_module.cpp
index ac381e9..e7a5ebd 100644
--- a/src/atframe/modules/etcd_module.cpp
+++ b/src/atframe/modules/etcd_module.cpp
@@ -80,7 +80,7 @@ static void init_timer_closed_callback(uv_handle_t *handle) {
 
 }  // namespace
 
-LIBATAPP_MACRO_API etcd_module::etcd_module() : enable_(false), atapp_(nullptr) {}
+LIBATAPP_MACRO_API etcd_module::etcd_module() : enable_(false), atapp_(nullptr), cluster_init_(false) {}
 
 LIBATAPP_MACRO_API etcd_module::~etcd_module() { reset(); }
 
@@ -90,6 +90,7 @@ LIBATAPP_MACRO_API int etcd_module::init(atframework::atapp::app &app, const ata
   load_cluster_conf(conf, log_conf);
   if (is_etcd_enabled()) {
     cluster_.init(atapp_->get_shared_curl_multi_context());
+    cluster_init_ = true;
   } else {
     FWLOGINFO("cluster is disabled");
   }
@@ -115,6 +116,7 @@ LIBATAPP_MACRO_API void etcd_module::reset() {
     cleanup_request_.reset();
   }
   cluster_.reset();
+  cluster_init_ = false;
 }
 
 LIBATAPP_MACRO_API bool etcd_module::check_keepalive_actor_start_success(
@@ -259,7 +261,7 @@ LIBATAPP_MACRO_API int etcd_module::tick() {
   }
 
   // first startup when reloaded
-  if (cluster_.check_flag(etcd_cluster::flag_t::kClosing)) {
+  if (!is_cluster_init()) {
     cluster_.init(atapp_->get_shared_curl_multi_context());
   }
 
@@ -505,6 +507,7 @@ int etcd_module::http_callback_on_etcd_closed(atfw::util::network::http_request
   }
 
   self->cleanup_request_.reset();
+  self->cluster_init_ = false;
   LIBATAPP_MACRO_ETCD_CLUSTER_LOG_DEBUG(self->cluster_, "Etcd revoke lease finished");
 
   if (self->atapp_ != nullptr) {
diff --git a/src/atframe/modules/service_discovery_module.cpp b/src/atframe/modules/service_discovery_module.cpp
index 7675f3f..3497936 100644
--- a/src/atframe/modules/service_discovery_module.cpp
+++ b/src/atframe/modules/service_discovery_module.cpp
@@ -319,8 +319,9 @@ LIBATAPP_MACRO_API int service_discovery_module::tick() {
   bool discovery_keepalives_watchers_inited = discovery_keepalives_watchers_inited_;
   {
     cluster_context_->tick();
-    if (!cluster_context_->get_etcd_module().is_cluster_closing()) {
-      // 不是正在关闭状态
+    if (cluster_context_->get_etcd_module().is_cluster_init() &&
+        !cluster_context_->get_etcd_module().is_cluster_closing()) {
+      // 初始化过且不是正在关闭状态
       if (discovery_enabled_ && !discovery_keepalives_watchers_inited) {
         init_service_discovery_keepalives_watchers(cluster_context_, false);
         discovery_keepalives_watchers_inited_ = true;
@@ -335,8 +336,9 @@ LIBATAPP_MACRO_API int service_discovery_module::tick() {
 
   for (const auto &external_cluster_context : external_cluster_contexts_) {
     external_cluster_context->tick();
-    if (!external_cluster_context->get_etcd_module().is_cluster_closing()) {
-      // 不是正在关闭状态
+    if (cluster_context_->get_etcd_module().is_cluster_init() &&
+        !cluster_context_->get_etcd_module().is_cluster_closing()) {
+      // 初始化过且不是正在关闭状态
       if (discovery_enabled_ && !discovery_keepalives_watchers_inited) {
         init_service_discovery_keepalives_watchers(external_cluster_context, false);
         discovery_keepalives_watchers_inited_ = true;