diff --git a/include/atframe/atapp.h b/include/atframe/atapp.h
index d4d31f5..2cc816e 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 LIBATAPP_MACRO_API 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/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/etcdcli/etcd_discovery.h b/include/atframe/etcdcli/etcd_discovery.h
index a633867..355b00a 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 copy_from(const atapp::protocol::atapp_discovery &input, const node_version &version,
+                                    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_addr() const noexcept { return context_addr_; }
 
   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_addr_;
 
   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..7922f28 100644
--- a/include/atframe/modules/etcd_module.h
+++ b/include/atframe/modules/etcd_module.h
@@ -6,293 +6,67 @@
 
 #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 tick();
 
-  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 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 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();
-
-  struct watcher_internal_access_t;
-
- private:
-  std::string conf_path_cache_;
-  std::string custom_data_;
-  atfw::util::network::http_request::curl_m_bind_ptr_t curl_multi_;
+  bool enable_;
   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_;
-  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_;
+  atframework::atapp::app *ATFW_UTIL_MACRO_NULLABLE atapp_;
+  bool cluster_init_;
+  atapp::etcd_cluster cluster_;
 
-  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_;
+  // Config
+  std::string conf_path_cache_;
+  atapp::protocol::atapp_etcd conf_cache_;
 };
 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..15f36cc
--- /dev/null
+++ b/include/atframe/modules/service_discovery_module.h
@@ -0,0 +1,337 @@
+// 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_addr = 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_addr = 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();
+    LIBATAPP_MACRO_API void reset();
+
+   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;
+  LIBATAPP_MACRO_API int timeout() 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 void reset_context_internal_watchers_and_keepalives();
+  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,
+      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,
+      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,
+      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,
+      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,
+      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,
+      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,
+      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,
+      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,
+      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;
+  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,
+      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,
+      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);
+
+  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(
+      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(
+      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);
+  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_;
+  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_;
+
+  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_;
+
+  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/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..3706907 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>
@@ -46,7 +49,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 +328,31 @@ static std::chrono::system_clock::duration &atapp_get_sys_now_offset() {
 
 }  // namespace
 
+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 == CURLE_OK) {
+      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() {
+  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() {}
 
@@ -441,8 +469,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 +560,11 @@ LIBATAPP_MACRO_API app::~app() {
     bus_node_.reset();
   }
 
+  // reset curl multi
+  if (curl_multi_) {
+    atfw::util::network::http_request::destroy_curl_multi(curl_multi_);
+  }
+
   // finally events
   app_evt_on_finally();
 
@@ -716,6 +749,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 +1243,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 +1402,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 +1429,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 +1487,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 +1703,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 +1715,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 +1727,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 +1739,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 +1752,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 +1764,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 +1776,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 +1799,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 +1840,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 +1919,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 +1930,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 +2003,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 +2106,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 +2167,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 +2210,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 +3294,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 +4138,27 @@ 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(multi_options, curl_multi_);
+  if (!curl_multi_) {
+    FWLOGERROR("create curl multi instance failed.");
+    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,41 +4862,41 @@ 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_) {
-    const char *msg = "Etcd module is not initialized, skip command.";
+int app::command_handler_disable_discovery(atfw::util::cli::callback_param params) {
+  if (!internal_module_service_discovery_) {
+    const char *msg = "Service discovery module 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();
-    const char *msg = "Etcd context is disabled now.";
+  } else if (internal_module_service_discovery_->is_discovery_enabled()) {
+    internal_module_service_discovery_->disable_discovery();
+    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);
   }
   return 0;
 }
 
-int app::command_handler_enable_etcd(atfw::util::cli::callback_param params) {
-  if (!internal_module_etcd_) {
-    const char *msg = "Etcd module not initialized, skip command.";
+int app::command_handler_enable_discovery(atfw::util::cli::callback_param params) {
+  if (!internal_module_service_discovery_) {
+    const char *msg = "Service discovery module not initialized, skip command.";
     FWLOGERROR("{}", msg);
     add_custom_command_rsp(params, msg);
-  } else if (internal_module_etcd_->is_etcd_enabled()) {
-    const char *msg = "Etcd context is already enabled, skip command.";
+  } else if (internal_module_service_discovery_->is_discovery_enabled()) {
+    const char *msg = "Service discovery 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()) {
-      const char *msg = "Etcd context is enabled now.";
+    internal_module_service_discovery_->enable_discovery();
+    if (internal_module_service_discovery_->is_discovery_enabled()) {
+      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);
     }
@@ -4843,8 +4906,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 +4920,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 +5345,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..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() : 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,13 +269,15 @@ 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_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_addr_ = context_addr;
+
   node_version_ = version;
 }
 
diff --git a/src/atframe/modules/etcd_module.cpp b/src/atframe/modules/etcd_module.cpp
index dbaf1b9..e7a5ebd 100644
--- a/src/atframe/modules/etcd_module.cpp
+++ b/src/atframe/modules/etcd_module.cpp
@@ -25,6 +25,7 @@
 #include <atframe/etcdcli/etcd_watcher.h>
 
 #include <algorithm>
+#include <list>
 #include <memory>
 #include <string>
 #include <unordered_map>
@@ -40,9 +41,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 +78,63 @@ 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;
-  }
-
-  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;
-}
+}  // namespace
 
-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;
-    }
+LIBATAPP_MACRO_API etcd_module::etcd_module() : enable_(false), atapp_(nullptr), cluster_init_(false) {}
 
-    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;
-    }
+LIBATAPP_MACRO_API etcd_module::~etcd_module() { reset(); }
 
-    if (new_version.version > storage.version.version) {
-      storage.version.version = new_version.version;
-      ret = true;
-    }
+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 (is_etcd_enabled()) {
+    cluster_.init(atapp_->get_shared_curl_multi_context());
+    cluster_init_ = true;
   } else {
-    storage.version = new_version;
-    ret = true;
+    FWLOGINFO("cluster is disabled");
   }
-
-  return ret;
+  return 0;
 }
-}  // 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;
+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;
+  }
+  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();
+  cluster_init_ = false;
 }
 
-// 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 +149,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 +164,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 +180,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 +190,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 +218,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 +240,88 @@ 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_);
-      }
-    }
+LIBATAPP_MACRO_API int etcd_module::tick() {
+  if (atapp_ == nullptr) {
+    return 0;
   }
-}
 
-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;
+  if (!is_etcd_enabled()) {
+    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();
-    }
+  // previous closing not finished, wait for it
+  if (cleanup_request_ || atapp_->is_closing()) {
+    return cluster_.tick();
   }
-  maybe_update_internal_keepalive_discovery_metadata_ = false;
 
-  if (!has_changed) {
-    return;
+  // first startup when reloaded
+  if (!is_cluster_init()) {
+    cluster_.init(atapp_->get_shared_curl_multi_context());
   }
 
-  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());
+  if (cleanup_request_ && cleanup_request_->is_running()) {
+    return 1;
   }
 
+  // recycle all resources
+  reset();
   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);
-
-  return 0;
-}
+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;
+  }
 
-LIBATAPP_MACRO_API int etcd_module::reload() {
   // 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 +338,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 +350,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 +415,120 @@ 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());
-  }
-
-  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));
+    cluster_.set_conf_ssl_cipher_list_tls13(conf.ssl().ssl_cipher_list_tls13());
   }
-  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->cleanup_request_.reset();
+  self->cluster_init_ = false;
+  LIBATAPP_MACRO_ETCD_CLUSTER_LOG_DEBUG(self->cluster_, "Etcd revoke lease finished");
 
-  if (fn) {
-    topology_watcher_callbacks_.push_back(fn);
+  if (self->atapp_ != nullptr) {
+    self->atapp_->stop();
   }
   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..3497936
--- /dev/null
+++ b/src/atframe/modules/service_discovery_module.cpp
@@ -0,0 +1,1789 @@
+// 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 <list>
+#include <memory>
+#include <set>
+#include <string>
+#include <unordered_map>
+#include <utility>
+#include <vector>
+
+#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) {
+  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;
+  }
+
+  return ret;
+}
+}  // namespace
+
+struct ATFW_UTIL_SYMBOL_LOCAL service_discovery_module::topology_watcher_callback_list_wrapper_t {
+  service_discovery_module *ATFW_UTIL_MACRO_NONNULL mod;
+  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;
+  int64_t snapshot_index;
+  bool has_insert_snapshot_index;
+
+  topology_watcher_callback_list_wrapper_t(
+      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,
+      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,
+                  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 *ATFW_UTIL_MACRO_NONNULL mod;
+  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;
+  int64_t snapshot_index;
+  bool has_insert_snapshot_index;
+
+  discovery_watcher_callback_list_wrapper_t(
+      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,
+      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,
+                  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 &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 &ctx,
+                                         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),
+      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),
+      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);
+  if (ret < 0) {
+    return ret;
+  }
+
+  for (const auto &config : get_app()->get_origin_configure().external_discovery()) {
+    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()) {
+      continue;
+    }
+    external_cluster_contexts_.push_back(std::move(external_cluster_context));
+  }
+
+  if (!cluster_context_->get_etcd_module().is_etcd_enabled()) {
+    return 0;
+  }
+
+  ret = init_service_discovery_keepalives_watchers(cluster_context_);
+  if (ret < 0) {
+    stop();
+    return ret;
+  }
+
+  for (const auto &external_cluster_context : external_cluster_contexts_) {
+    ret = init_service_discovery_keepalives_watchers(external_cluster_context);
+    if (ret < 0) {
+      stop();
+      return ret;
+    }
+  }
+  discovery_keepalives_watchers_inited_ = true;
+
+  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() {
+  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;
+}
+
+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() {
+  // 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_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;
+      }
+      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 (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;
+      }
+      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();
+  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();
+  for (const auto &external_cluster_context : external_cluster_contexts_) {
+    external_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_;
+}
+
+LIBATAPP_MACRO_API void service_discovery_module::enable_discovery() {
+  if (is_discovery_enabled()) {
+    return;
+  }
+  discovery_enabled_ = true;
+}
+
+LIBATAPP_MACRO_API void service_discovery_module::disable_discovery() {
+  if (!is_discovery_enabled()) {
+    return;
+  }
+  discovery_enabled_ = false;
+}
+
+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_);
+      }
+    }
+    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_);
+        }
+      }
+    }
+  }
+}
+
+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_);
+      }
+    }
+    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_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();
+
+  int ret = 0;
+
+  atframework::atapp::app &app = *get_app();
+  if (context->get_etcd_module().get_configure().keepalive().enabled()) {
+    int result = init_topology_keepalive(app, context, internal_keepalive_topology_value_);
+    if (result < 0) {
+      ret = result;
+    }
+    result = init_discovery_keepalive_by_id(app, context, internal_keepalive_discovery_value_);
+    if (result < 0) {
+      ret = result;
+    }
+    result = init_discovery_keepalive_by_name(app, context, internal_keepalive_discovery_value_);
+    if (result < 0) {
+      ret = result;
+    }
+  }
+
+  if (context->get_etcd_module().get_configure().watcher().enabled()) {
+    int result = add_topology_watcher_callback(app, context, nullptr);
+    if (result < 0) {
+      ret = result;
+    }
+    result = add_discovery_watcher_by_id_callback(app, context, nullptr);
+    if (result < 0) {
+      ret = result;
+    }
+    result = add_discovery_watcher_by_name_callback(app, context, nullptr);
+    if (result < 0) {
+      ret = result;
+    }
+  }
+
+  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(
+    atframework::atapp::app &app,
+    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) {
+    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,
+    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) {
+    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,
+    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) {
+    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,
+    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);
+
+    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,
+    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 =
+        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,
+    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 =
+        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 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_;
+}
+
+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(
+    atframework::atapp::app &app,
+    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) {
+    return ret;
+  }
+  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,
+    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) {
+    return ret;
+  }
+  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,
+    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) {
+    return ret;
+  }
+  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,
+    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;
+
+  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,
+    const ::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);
+}
+
+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(
+    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(
+    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_));
+}
+
+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_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_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_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_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());
+  }
+}
+
+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_addr != reinterpret_cast<uintptr_t>(&ctx)) {
+      // 只有相同 context 才会进行清理
+      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,
+    const ::atfw::util::nostd::nonnull<std::shared_ptr<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,
+    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),
+      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() {
+  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);
+  }
+}
+
+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;
+  }
+  auto ctx_locked = ctx.lock();
+  if (ctx_locked == nullptr) {
+    return;
+  }
+  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_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_locked->data_->discovery_watcher_snapshot_index_.empty() &&
+        *ctx_locked->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_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,
+           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_locked, 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,
+    const ::atfw::util::nostd::nonnull<std::shared_ptr<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,
+    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),
+      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() {
+  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);
+  }
+}
+
+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;
+  }
+  auto ctx_locked = ctx.lock();
+  if (ctx_locked == nullptr) {
+    return;
+  }
+  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_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_locked->data_->topology_watcher_snapshot_index_.empty() &&
+        *ctx_locked->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_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);
+    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_locked, 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) {
+        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),                       // 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);
+        global_discovery_.remove_node(local_cache_by_id);
+
+        has_event = true;
+      }
+    } else {
+      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 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),                       // 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)) {
+          local_cache_by_id->update_version(version, true);
+          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_addr);
+      global_discovery_.add_node(new_inst);
+
+      has_event = true;
+    }
+  } else {
+    if (node_action_t::kDelete == node.action) {
+      // 有一个节点 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),                       // 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);
+          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. 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 *>(                       // 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);
+          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_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_addr() == node.context_addr)) {
+        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_addr);
+
+        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 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;
+    }
+
+    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()) {
+      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 {} from context {}, but current context is {}, ignore it",
+            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;
+      }
+
+      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) {
+        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();
+  }
+
+  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();
+}
+
+LIBATAPP_MACRO_NAMESPACE_END
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..4041ef7 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);
@@ -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..7738d59 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>
@@ -16,6 +17,8 @@
 #include <cstdlib>
 #include <memory>
 #include <string>
+#include <unordered_map>
+#include <unordered_set>
 #include <vector>
 
 #include "frame/test_macros.h"
@@ -103,23 +106,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 +146,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 +161,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 +197,19 @@ 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 +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(), 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 +255,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 +307,19 @@ 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 +344,18 @@ 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 +385,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 +414,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 +431,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 +464,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 +485,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 +508,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 +522,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 +549,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 +594,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 +621,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 +634,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 +696,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 +725,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 +780,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 +813,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 +842,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 +863,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 +890,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 +913,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 +956,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 +987,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 +1015,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 +1056,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::unordered_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 +1088,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 +1098,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 +1130,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 +1141,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 +1168,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::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,
+          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 +1211,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 +1250,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 +1275,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 +1331,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::unordered_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 +1403,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 +1414,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,30 +1430,32 @@ 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;
     }
 
     std::vector<atframework::atapp::app *> apps = {&app1, &app2};
 
     // 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); });
+    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';
 
     // 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 +1468,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 +1501,504 @@ 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());
+  CASE_MSG_INFO() << "multi_node_custom_data: local set/get API verified" << '\n';
+}
 
-  etcd_mod1->set_conf_custom_data("");
-  CASE_EXPECT_TRUE(etcd_mod1->get_conf_custom_data().empty());
+// ============================================================
+// 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;
+  }
 
-  CASE_MSG_INFO() << "multi_node_custom_data: local set/get API verified" << '\n';
+  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
+  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_watchers(service_discovery_context);
+    CASE_EXPECT_TRUE(ret == 0);
+    if (ret != 0) {
+      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));
+  auto discovery3 = app3.get_service_discovery_module();
+  CASE_EXPECT_TRUE(!!discovery3);
+  if (!discovery3) {
+    return;
+  }
+
+  auto service_discovery_context_a =
+      std::make_shared<atframework::atapp::service_discovery_module::service_discovery_cluster_context>();
+  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_keepalives_watchers(service_discovery_context_a);
+  CASE_EXPECT_TRUE(ret == 0);
+  if (ret != 0) {
+    return;
+  }
+
+  auto service_discovery_context_b =
+      std::make_shared<atframework::atapp::service_discovery_module::service_discovery_cluster_context>();
+  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_keepalives_watchers(service_discovery_context_b);
+  CASE_EXPECT_TRUE(ret == 0);
+  if (ret != 0) {
+    return;
+  }
+
+  // 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;
+  }
+  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_etcd_module_unit_test.cpp b/test/case/atapp_etcd_module_unit_test.cpp
index 908bbd2..eb5969f 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_addr = 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_addr = 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_addr = 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_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_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
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
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();