diff --git a/src/client/WFConsulClient.cc b/src/client/WFConsulClient.cc
deleted file mode 100644
index e0d8767..0000000
--- a/src/client/WFConsulClient.cc
+++ /dev/null
@@ -1,1477 +0,0 @@
-/*
-  Copyright (c) 2022 Sogou, Inc.
-
-  Licensed under the Apache License, Version 2.0 (the "License");
-  you may not use this file except in compliance with the License.
-  You may obtain a copy of the License at
-
-      http://www.apache.org/licenses/LICENSE-2.0
-
-  Unless required by applicable law or agreed to in writing, software
-  distributed under the License is distributed on an "AS IS" BASIS,
-  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-  See the License for the specific language governing permissions and
-  limitations under the License.
-
-  Authors: Wang Zhenpeng (wangzhenpeng@sogou-inc.com)
-*/
-
-#include <string.h>
-#include <string>
-#include <vector>
-#include <utility>
-#include <functional>
-#include "json_parser.h" // JSON解析工具
-#include "StringUtil.h"  // 字符串工具
-#include "URIParser.h"   // URI解析工具
-#include "HttpUtil.h"    // HTTP相关工具
-#include "WFConsulClient.h" // Consul客户端相关定义
-
-using namespace protocol; // 使用协议相关命名空间
-
-// WFConsulTask 构造函数
-WFConsulTask::WFConsulTask(const std::string& proxy_url,
-						   const std::string& service_namespace,
-						   const std::string& service_name,
-						   const std::string& service_id,
-						   int retry_max,
-						   consul_callback_t&& cb) :
-	proxy_url(proxy_url), // 初始化代理地址
-	callback(std::move(cb)) // 设置回调函数
-{
-	this->service.service_name = service_name; // 初始化服务名称
-	this->service.service_namespace = service_namespace; // 初始化服务命名空间
-	this->service.service_id = service_id; // 初始化服务 ID
-	this->api_type = CONSUL_API_TYPE_UNKNOWN; // 设置 API 类型为未知
-	this->retry_max = retry_max; // 设置最大重试次数
-	this->finish = false; // 标记任务未完成
-	this->consul_index = 0; // 初始化 Consul 索引为 0
-}
-
-// 设置服务相关信息
-void WFConsulTask::set_service(const struct protocol::ConsulService *service)
-{
-	this->service.tags = service->tags; // 设置服务标签
-	this->service.meta = service->meta; // 设置服务元信息
-	this->service.tag_override = service->tag_override; // 设置标签覆盖标志
-	this->service.service_address = service->service_address; // 设置服务地址
-	this->service.lan = service->lan; // 设置本地局域网地址
-	this->service.lan_ipv4 = service->lan_ipv4; // 设置 IPv4 地址
-	this->service.lan_ipv6 = service->lan_ipv6; // 设置 IPv6 地址
-	this->service.virtual_address = service->virtual_address; // 设置虚拟地址
-	this->service.wan = service->wan; // 设置广域网地址
-	this->service.wan_ipv4 = service->wan_ipv4; // 设置 IPv4 地址
-	this->service.wan_ipv6 = service->wan_ipv6; // 设置 IPv6 地址
-}
-
-
-// 解析服务发现结果的静态函数
-static bool parse_discover_result(const json_value_t *root,
-							std::vector<struct ConsulServiceInstance>& result);
-
-// 解析服务列表结果的静态函数
-static bool parse_list_service_result(const json_value_t *root,
-							std::vector<struct ConsulServiceTags>& result);
-
-
-// 获取服务发现结果
-bool WFConsulTask::get_discover_result(
-	std::vector<struct ConsulServiceInstance>& result)
-{
-	json_value_t *root;  // JSON 根节点
-	int errno_bak;       // 备份当前 errno 值
-	bool ret;            // 返回结果标志
-
-	// 检查当前 API 类型是否为服务发现
-	if (this->api_type != CONSUL_API_TYPE_DISCOVER)
-	{
-		errno = EPERM;   // 设置权限错误
-		return false;    // 返回失败
-	}
-
-	errno_bak = errno;      // 备份 errno
-	errno = EBADMSG;        // 设置消息错误
-	std::string body = HttpUtil::decode_chunked_body(&this->http_resp); // 解码 HTTP 响应的分块数据
-	root = json_value_parse(body.c_str());  // 解析 JSON 数据
-	if (!root)              // 如果解析失败
-		return false;        // 返回失败
-
-	ret = parse_discover_result(root, result);  // 解析服务发现结果
-	json_value_destroy(root);  // 销毁 JSON 对象
-	if (ret)                   // 如果解析成功
-		errno = errno_bak;      // 恢复原始 errno
-
-	return ret;                // 返回解析结果
-}
-
-
-// 获取服务列表结果
-bool WFConsulTask::get_list_service_result(
-	std::vector<struct ConsulServiceTags>& result)
-{
-	json_value_t *root;  // JSON 根节点
-	int errno_bak;       // 备份当前 errno 值
-	bool ret;            // 返回结果标志
-
-	// 检查当前 API 类型是否为服务列表
-	if (this->api_type != CONSUL_API_TYPE_LIST_SERVICE)
-	{
-		errno = EPERM;   // 设置权限错误
-		return false;    // 返回失败
-	}
-
-	errno_bak = errno;      // 备份 errno
-	errno = EBADMSG;        // 设置消息错误
-	std::string body = HttpUtil::decode_chunked_body(&this->http_resp); // 解码 HTTP 响应的分块数据
-	root = json_value_parse(body.c_str());  // 解析 JSON 数据
-	if (!root)              // 如果解析失败
-		return false;        // 返回失败
-
-	ret = parse_list_service_result(root, result);  // 解析服务列表结果
-	json_value_destroy(root);  // 销毁 JSON 对象
-	if (ret)                   // 如果解析成功
-		errno = errno_bak;      // 恢复原始 errno
-
-	return ret;                // 返回解析结果
-}
-
-
-// 分发任务，根据 API 类型选择相应的任务处理逻辑
-void WFConsulTask::dispatch()
-{
-	WFHttpTask *task;  // 定义 HTTP 任务指针
-
-	if (this->finish)  // 如果任务已完成
-	{
-		this->subtask_done();  // 标记子任务完成
-		return;                // 退出
-	}
-
-	// 根据 API 类型选择处理任务
-	switch(this->api_type)
-	{
-	case CONSUL_API_TYPE_DISCOVER:         // 如果是服务发现任务
-		task = create_discover_task();    // 创建服务发现任务
-		break;
-
-	case CONSUL_API_TYPE_LIST_SERVICE:     // 如果是服务列表任务
-		task = create_list_service_task(); // 创建服务列表任务
-		break;
-
-	case CONSUL_API_TYPE_DEREGISTER:       // 如果是注销服务任务
-		task = create_deregister_task();   // 创建注销服务任务
-		break;
-
-	case CONSUL_API_TYPE_REGISTER:         // 如果是注册服务任务
-		task = create_register_task();     // 创建注册服务任务
-		if (task)
-			break;
-
-		// 如果任务创建失败，设置错误状态
-		if (1)
-		{
-			this->state = WFT_STATE_SYS_ERROR; // 设置系统错误状态
-			this->error = errno;              // 设置错误码
-		}
-		else
-		{
-	default:
-			this->state = WFT_STATE_TASK_ERROR; // 设置任务错误状态
-			this->error = WFT_ERR_CONSUL_API_UNKNOWN; // 设置未知 API 错误
-		}
-
-		this->finish = true;  // 标记任务完成
-		this->subtask_done(); // 标记子任务完成
-		return;
-	}
-
-	// 将任务插入到工作队列
-	series_of(this)->push_front(this);  // 将当前任务加入队列
-	series_of(this)->push_front(task); // 将新任务加入队列
-	this->subtask_done();              // 标记子任务完成
-}
-
-
-// 标记任务完成，并执行回调或清理逻辑
-SubTask *WFConsulTask::done()
-{
-	SeriesWork *series = series_of(this); // 获取当前任务的工作队列
-
-	if (finish)  // 如果任务已完成
-	{
-		if (this->callback)   // 如果有回调函数
-			this->callback(this); // 执行回调函数
-
-		delete this;          // 删除任务对象
-	}
-
-	return series->pop();     // 从队列中弹出任务
-}
-
-
-// 将毫秒时间转换为字符串形式（如 "5s" 或 "3m"）
-static std::string convert_time_to_str(int milliseconds)
-{
-	std::string str_time;      // 保存时间字符串
-	int seconds = milliseconds / 1000; // 将毫秒转换为秒
-
-	if (seconds >= 180)        // 如果时间超过 3 分钟
-		str_time = std::to_string(seconds / 60) + "m"; // 转换为分钟形式
-	else
-		str_time = std::to_string(seconds) + "s";     // 转换为秒形式
-
-	return str_time;           // 返回时间字符串
-}
-
-
-// 生成服务发现请求的 URL
-std::string WFConsulTask::generate_discover_request()
-{
-	std::string url = this->proxy_url; // 初始化 URL 为代理地址
-
-	// 添加服务健康检查路径
-	url += "/v1/health/service/" + this->service.service_name;
-
-	// 添加数据中心参数
-	url += "?dc=" + this->config.get_datacenter();
-
-	// 添加服务命名空间参数
-	url += "&ns=" + this->service.service_namespace;
-
-	// 获取 passing 参数值，表示是否仅返回通过健康检查的服务实例
-	std::string passing = this->config.get_passing() ? "true" : "false";
-	url += "&passing=" + passing; // 添加 passing 参数
-
-	// 添加 token 参数用于鉴权
-	url += "&token=" + this->config.get_token();
-
-	// 添加过滤表达式参数
-	url += "&filter=" + this->config.get_filter_expr();
-
-	// 检查是否启用 Consul 阻塞查询
-	if (this->config.blocking_query())
-	{
-		// 添加索引参数，用于阻塞查询的初始状态
-		url += "&index=" + std::to_string(this->get_consul_index());
-
-		// 添加等待时间参数，表示阻塞查询的超时时间
-		url += "&wait=" + convert_time_to_str(this->config.get_wait_ttl());
-	}
-
-	return url; // 返回生成的 URL
-}
-
-
-// 创建服务发现任务
-WFHttpTask *WFConsulTask::create_discover_task()
-{
-	std::string url = generate_discover_request(); // 调用生成服务发现 URL 的函数
-	WFHttpTask *task = WFTaskFactory::create_http_task( // 创建 HTTP 任务
-		url, 0, this->retry_max, discover_callback);
-
-	HttpRequest *req = task->get_req(); // 获取 HTTP 请求对象
-
-	// 添加 HTTP 请求头，指定内容类型为 JSON
-	req->add_header_pair("Content-Type", "application/json");
-
-	task->user_data = this; // 设置用户数据为当前任务对象
-	return task; // 返回创建的任务
-}
-
-
-// 创建服务列表任务
-WFHttpTask *WFConsulTask::create_list_service_task()
-{
-	std::string url = this->proxy_url; // 初始化 URL 为代理地址
-
-	// 添加服务目录路径和鉴权 token
-	url += "/v1/catalog/services?token=" + this->config.get_token();
-
-	// 添加数据中心参数
-	url += "&dc=" + this->config.get_datacenter();
-
-	// 添加服务命名空间参数
-	url += "&ns=" + this->service.service_namespace;
-
-	WFHttpTask *task = WFTaskFactory::create_http_task( // 创建 HTTP 任务
-		url, 0, this->retry_max, list_service_callback);
-
-	HttpRequest *req = task->get_req(); // 获取 HTTP 请求对象
-
-	// 添加 HTTP 请求头，指定内容类型为 JSON
-	req->add_header_pair("Content-Type", "application/json");
-
-	task->user_data = this; // 设置用户数据为当前任务对象
-	return task; // 返回创建的任务
-}
-
-
-static void print_json_value(const json_value_t *val, int depth,
-							 std::string& json_str);
-
-static bool create_register_request(const json_value_t *root,
-									const struct ConsulService *service,
-									const ConsulConfig& config);
-
-// 创建服务注册任务
-WFHttpTask *WFConsulTask::create_register_task()
-{
-	std::string payload; // 定义用于存储请求体的字符串
-
-	std::string url = this->proxy_url; // 初始化 URL 为代理地址
-	// 添加服务注册路径和替换检查选项
-	url += "/v1/agent/service/register?replace-existing-checks=";
-	url += this->config.get_replace_checks() ? "true" : "false";
-
-	WFHttpTask *task = WFTaskFactory::create_http_task( // 创建 HTTP 任务
-		url, 0, this->retry_max, register_callback);
-
-	HttpRequest *req = task->get_req(); // 获取 HTTP 请求对象
-
-	req->set_method(HttpMethodPut); // 设置 HTTP 方法为 PUT
-	req->add_header_pair("Content-Type", "application/json"); // 添加内容类型头
-
-	// 如果存在鉴权 token，则添加到请求头
-	if (!this->config.get_token().empty())
-		req->add_header_pair("X-Consul-Token", this->config.get_token());
-
-	json_value_t *root = json_value_create(JSON_VALUE_OBJECT); // 创建 JSON 对象根节点
-	if (root) // 如果创建成功
-	{
-		// 构建服务注册请求 JSON 数据
-		if (create_register_request(root, &this->service, this->config))
-			print_json_value(root, 0, payload); // 将 JSON 数据转为字符串
-
-		json_value_destroy(root); // 销毁 JSON 对象
-		// 如果请求体不为空且追加到请求成功
-		if (!payload.empty() && req->append_output_body(payload))
-		{
-			task->user_data = this; // 设置用户数据为当前任务对象
-			return task; // 返回创建的任务
-		}
-	}
-
-	task->dismiss(); // 如果失败，销毁任务
-	return NULL; // 返回空指针
-}
-
-
-// 创建服务注销任务
-WFHttpTask *WFConsulTask::create_deregister_task()
-{
-	std::string url = this->proxy_url; // 初始化 URL 为代理地址
-
-	// 添加服务注销路径，包含服务 ID 和命名空间参数
-	url += "/v1/agent/service/deregister/" + this->service.service_id;
-	url += "?ns=" + this->service.service_namespace;
-
-	WFHttpTask *task = WFTaskFactory::create_http_task( // 创建 HTTP 任务
-		url, 0, this->retry_max, register_callback);
-
-	HttpRequest *req = task->get_req(); // 获取 HTTP 请求对象
-
-	req->set_method(HttpMethodPut); // 设置 HTTP 方法为 PUT
-	req->add_header_pair("Content-Type", "application/json"); // 添加内容类型头
-
-	// 如果存在鉴权 token，则添加到请求头
-	std::string token = this->config.get_token();
-	if (!token.empty())
-		req->add_header_pair("X-Consul-Token", token);
-
-	task->user_data = this; // 设置用户数据为当前任务对象
-	return task; // 返回创建的任务
-}
-
-
-// 检查任务执行结果
-bool WFConsulTask::check_task_result(WFHttpTask *task, WFConsulTask *consul_task)
-{
-	// 如果任务状态不是成功状态
-	if (task->get_state() != WFT_STATE_SUCCESS)
-	{
-		consul_task->state = task->get_state(); // 设置任务状态
-		consul_task->error = task->get_error(); // 设置错误信息
-		return false; // 返回失败
-	}
-
-	// 获取任务的 HTTP 响应
-	protocol::HttpResponse *resp = task->get_resp();
-
-	// 检查 HTTP 响应状态码是否为 "200"
-	if (strcmp(resp->get_status_code(), "200") != 0)
-	{
-		consul_task->state = WFT_STATE_TASK_ERROR; // 设置任务错误状态
-		consul_task->error = WFT_ERR_CONSUL_CHECK_RESPONSE_FAILED; // 设置响应失败错误
-		return false; // 返回失败
-	}
-
-	return true; // 返回成功
-}
-
-
-// 从 HTTP 响应头中获取 Consul 索引
-long long WFConsulTask::get_consul_index(HttpResponse *resp)
-{
-	long long consul_index = 0; // 初始化 Consul 索引为 0
-
-	// 创建 HTTP 头游标以遍历响应头
-	protocol::HttpHeaderCursor cursor(resp);
-	std::string consul_index_str; // 用于存储 Consul 索引字符串
-
-	// 查找 "X-Consul-Index" 响应头
-	if (cursor.find("X-Consul-Index", consul_index_str))
-	{
-		// 将字符串转换为长整型
-		consul_index = strtoll(consul_index_str.c_str(), NULL, 10);
-		if (consul_index < 0) // 如果索引小于 0，则重置为 0
-			consul_index = 0;
-	}
-
-	return consul_index; // 返回 Consul 索引
-}
-
-
-// 服务发现任务的回调函数
-void WFConsulTask::discover_callback(WFHttpTask *task)
-{
-	WFConsulTask *t = (WFConsulTask*)task->user_data; // 获取任务的用户数据
-
-	// 检查任务执行结果
-	if (WFConsulTask::check_task_result(task, t))
-	{
-		protocol::HttpResponse *resp = task->get_resp(); // 获取 HTTP 响应
-		long long consul_index = t->get_consul_index(resp); // 获取当前 Consul 索引
-		long long last_consul_index = t->get_consul_index(); // 获取上一次的 Consul 索引
-
-		// 更新 Consul 索引，如果当前索引小于上次索引，则重置为 0
-		t->set_consul_index(consul_index < last_consul_index ? 0 : consul_index);
-		t->state = task->get_state(); // 设置任务状态
-	}
-
-	// 将 HTTP 响应转移到任务对象
-	t->http_resp = std::move(*task->get_resp());
-	t->finish = true; // 标记任务完成
-}
-
-
-// 服务列表任务的回调函数
-void WFConsulTask::list_service_callback(WFHttpTask *task)
-{
-	WFConsulTask *t = (WFConsulTask*)task->user_data; // 获取任务的用户数据
-
-	// 检查任务执行结果
-	if (WFConsulTask::check_task_result(task, t))
-		t->state = task->get_state(); // 设置任务状态
-
-	// 将 HTTP 响应转移到任务对象
-	t->http_resp = std::move(*task->get_resp());
-	t->finish = true; // 标记任务完成
-}
-
-
-// 服务注册任务的回调函数
-void WFConsulTask::register_callback(WFHttpTask *task)
-{
-	WFConsulTask *t = (WFConsulTask *)task->user_data; // 获取任务的用户数据
-
-	// 检查任务执行结果
-	if (WFConsulTask::check_task_result(task, t))
-		t->state = task->get_state(); // 设置任务状态
-
-	// 将 HTTP 响应转移到任务对象
-	t->http_resp = std::move(*task->get_resp());
-	t->finish = true; // 标记任务完成
-}
-
-
-// 初始化 Consul 客户端
-int WFConsulClient::init(const std::string& proxy_url, ConsulConfig config)
-{
-	ParsedURI uri; // 定义用于存储解析后的 URI 的对象
-
-	// 解析代理 URL
-	if (URIParser::parse(proxy_url, uri) >= 0)
-	{
-		// 构建完整的代理 URL
-		this->proxy_url = uri.scheme;
-		this->proxy_url += "://";
-		this->proxy_url += uri.host;
-		if (uri.port) // 如果指定了端口，则追加端口信息
-		{
-			this->proxy_url += ":";
-			this->proxy_url += uri.port;
-		}
-
-		this->config = std::move(config); // 将配置赋值给客户端
-		return 0; // 返回成功
-	}
-	else if (uri.state == URI_STATE_INVALID) // 如果 URI 无效
-		errno = EINVAL; // 设置错误码为无效参数
-
-	return -1; // 返回失败
-}
-
-
-// 初始化 Consul 客户端（使用默认配置）
-int WFConsulClient::init(const std::string& proxy_url)
-{
-	return this->init(proxy_url, ConsulConfig()); // 调用带配置参数的 init 函数
-}
-
-
-// 创建服务发现任务
-WFConsulTask *WFConsulClient::create_discover_task(
-	const std::string& service_namespace,
-	const std::string& service_name,
-	int retry_max,
-	consul_callback_t cb)
-{
-	// 创建一个新的 Consul 任务
-	WFConsulTask *task = new WFConsulTask(this->proxy_url, service_namespace,
-										  service_name, "", retry_max,
-										  std::move(cb));
-
-	task->set_api_type(CONSUL_API_TYPE_DISCOVER); // 设置任务类型为服务发现
-	task->set_config(this->config); // 设置任务的配置信息
-	return task; // 返回创建的任务
-}
-
-
-// 创建服务列表任务
-WFConsulTask *WFConsulClient::create_list_service_task(
-	const std::string& service_namespace,
-	int retry_max,
-	consul_callback_t cb)
-{
-	// 创建一个新的 Consul 任务
-	WFConsulTask *task = new WFConsulTask(this->proxy_url, service_namespace,
-										  "", "", retry_max,
-										  std::move(cb));
-
-	task->set_api_type(CONSUL_API_TYPE_LIST_SERVICE); // 设置任务类型为服务列表
-	task->set_config(this->config); // 设置任务的配置信息
-	return task; // 返回创建的任务
-}
-
-
-// 创建服务注册任务
-WFConsulTask *WFConsulClient::create_register_task(
-	const std::string& service_namespace,
-	const std::string& service_name,
-	const std::string& service_id,
-	int retry_max,
-	consul_callback_t cb)
-{
-	// 创建一个新的 Consul 任务
-	WFConsulTask *task = new WFConsulTask(this->proxy_url, service_namespace,
-										  service_name, service_id, retry_max,
-										  std::move(cb));
-
-	task->set_api_type(CONSUL_API_TYPE_REGISTER); // 设置任务类型为服务注册
-	task->set_config(this->config); // 设置任务的配置信息
-	return task; // 返回创建的任务
-}
-
-
-// 创建服务注销任务
-WFConsulTask *WFConsulClient::create_deregister_task(
-	const std::string& service_namespace,
-	const std::string& service_id,
-	int retry_max,
-	consul_callback_t cb)
-{
-	// 创建一个新的 Consul 任务
-	WFConsulTask *task = new WFConsulTask(this->proxy_url, service_namespace,
-										  "", service_id, retry_max,
-										  std::move(cb));
-
-	task->set_api_type(CONSUL_API_TYPE_DEREGISTER); // 设置任务类型为服务注销
-	task->set_config(this->config); // 设置任务的配置信息
-	return task; // 返回创建的任务
-}
-
-
-// 创建带标签的地址对象
-static bool create_tagged_address(const ConsulAddress& consul_address,
-								  const std::string& name,
-								  json_object_t *tagged_obj)
-{
-	// 如果地址为空，直接返回成功
-	if (consul_address.first.empty())
-		return true;
-
-	// 向 JSON 对象中添加名为 name 的嵌套对象
-	const json_value_t *val = json_object_append(tagged_obj, name.c_str(),
-												 JSON_VALUE_OBJECT);
-	if (!val) // 如果添加失败，返回 false
-		return false;
-
-	// 获取新创建的嵌套对象
-	json_object_t *obj = json_value_object(val);
-	if (!obj) // 如果对象获取失败，返回 false
-		return false;
-
-	// 向嵌套对象中添加 "Address" 字段
-	if (!json_object_append(obj, "Address", JSON_VALUE_STRING,
-							consul_address.first.c_str()))
-		return false;
-
-	// 向嵌套对象中添加 "Port" 字段
-	if (!json_object_append(obj, "Port", JSON_VALUE_NUMBER,
-							(double)consul_address.second))
-		return false;
-
-	return true; // 地址对象创建成功
-}
-
-
-// 创建健康检查配置
-static bool create_health_check(const ConsulConfig& config, json_object_t *obj)
-{
-	const json_value_t *val; // 存储添加字段的返回值
-	std::string str; // 临时字符串存储变量
-
-	// 如果未启用健康检查，直接返回成功
-	if (!config.get_health_check())
-		return true;
-
-	// 在 JSON 对象中添加 "Check" 字段
-	val = json_object_append(obj, "Check", JSON_VALUE_OBJECT);
-	if (!val) // 如果添加失败，返回 false
-		return false;
-
-	obj = json_value_object(val); // 获取 "Check" 对象
-	if (!obj) // 如果对象获取失败，返回 false
-		return false;
-
-	// 添加健康检查的名称
-	str = config.get_check_name();
-	if (!json_object_append(obj, "Name", JSON_VALUE_STRING, str.c_str()))
-		return false;
-
-	// 添加健康检查的备注
-	str = config.get_check_notes();
-	if (!json_object_append(obj, "Notes", JSON_VALUE_STRING, str.c_str()))
-		return false;
-
-	// 添加健康检查的 HTTP URL
-	str = config.get_check_http_url();
-	if (!str.empty()) // 如果 URL 不为空
-	{
-		if (!json_object_append(obj, "HTTP", JSON_VALUE_STRING, str.c_str()))
-			return false;
-
-		// 添加 HTTP 方法
-		str = config.get_check_http_method();
-		if (!json_object_append(obj, "Method", JSON_VALUE_STRING, str.c_str()))
-			return false;
-
-		// 添加 HTTP 请求体
-		str = config.get_http_body();
-		if (!json_object_append(obj, "Body", JSON_VALUE_STRING, str.c_str()))
-			return false;
-
-		// 添加 HTTP 头部信息
-		val = json_object_append(obj, "Header", JSON_VALUE_OBJECT);
-		if (!val)
-			return false;
-
-		json_object_t *header_obj = json_value_object(val);
-		if (!header_obj)
-			return false;
-
-		// 遍历并添加所有 HTTP 头部字段
-		for (const auto& header : *config.get_http_headers())
-		{
-			val = json_object_append(header_obj, header.first.c_str(),
-									 JSON_VALUE_ARRAY);
-			if (!val)
-				return false;
-
-			json_array_t *arr = json_value_array(val);
-			if (!arr)
-				return false;
-
-			// 添加头部字段对应的多个值
-			for (const auto& value : header.second)
-			{
-				if (!json_array_append(arr, JSON_VALUE_STRING, value.c_str()))
-					return false;
-			}
-		}
-	}
-
-	// 添加 TCP 检查地址
-	str = config.get_check_tcp();
-	if (!str.empty())
-	{
-		if (!json_object_append(obj, "TCP", JSON_VALUE_STRING, str.c_str()))
-			return false;
-	}
-
-	// 添加初始状态
-	str = config.get_initial_status();
-	if (!json_object_append(obj, "Status", JSON_VALUE_STRING, str.c_str()))
-		return false;
-
-	// 添加自动注销时间
-	str = convert_time_to_str(config.get_auto_deregister_time());
-	if (!json_object_append(obj, "DeregisterCriticalServiceAfter",
-							JSON_VALUE_STRING, str.c_str()))
-		return false;
-
-	// 添加检查间隔时间
-	str = convert_time_to_str(config.get_check_interval());
-	if (!json_object_append(obj, "Interval", JSON_VALUE_STRING, str.c_str()))
-		return false;
-
-	// 添加检查超时时间
-	str = convert_time_to_str(config.get_check_timeout());
-	if (!json_object_append(obj, "Timeout", JSON_VALUE_STRING, str.c_str()))
-		return false;
-
-	// 添加连续成功次数限制
-	if (!json_object_append(obj, "SuccessBeforePassing", JSON_VALUE_NUMBER,
-							(double)config.get_success_times()))
-		return false;
-
-	// 添加连续失败次数限制
-	if (!json_object_append(obj, "FailuresBeforeCritical", JSON_VALUE_NUMBER,
-							(double)config.get_failure_times()))
-		return false;
-
-	return true; // 健康检查配置创建成功
-}
-
-
-// 创建服务注册请求
-static bool create_register_request(const json_value_t *root,
-									const struct ConsulService *service,
-									const ConsulConfig& config)
-{
-	const json_value_t *val; // 临时存储 JSON 值
-	json_object_t *obj; // 临时存储 JSON 对象
-
-	obj = json_value_object(root); // 获取根对象
-	if (!obj)
-		return false;
-
-	// 添加服务 ID
-	if (!json_object_append(obj, "ID", JSON_VALUE_STRING,
-							service->service_id.c_str()))
-		return false;
-
-	// 添加服务名称
-	if (!json_object_append(obj, "Name", JSON_VALUE_STRING,
-							service->service_name.c_str()))
-		return false;
-
-	// 如果命名空间非空，则添加命名空间
-	if (!service->service_namespace.empty())
-	{
-		if (!json_object_append(obj, "ns", JSON_VALUE_STRING,
-								service->service_namespace.c_str()))
-			return false;
-	}
-
-	// 添加服务标签数组
-	val = json_object_append(obj, "Tags", JSON_VALUE_ARRAY);
-	if (!val)
-		return false;
-
-	json_array_t *arr = json_value_array(val);
-	if (!arr)
-		return false;
-
-	// 遍历并添加所有标签
-	for (const auto& tag : service->tags)
-	{
-		if (!json_array_append(arr, JSON_VALUE_STRING, tag.c_str()))
-			return false;
-	}
-
-	// 添加服务地址
-	if (!json_object_append(obj, "Address", JSON_VALUE_STRING,
-							service->service_address.first.c_str()))
-		return false;
-
-	// 添加服务端口
-	if (!json_object_append(obj, "Port", JSON_VALUE_NUMBER,
-							(double)service->service_address.second))
-		return false;
-
-	// 添加元数据对象
-	val = json_object_append(obj, "Meta", JSON_VALUE_OBJECT);
-	if (!val)
-		return false;
-
-	json_object_t *meta_obj = json_value_object(val);
-	if (!meta_obj)
-		return false;
-
-	// 遍历并添加所有元数据
-	for (const auto& meta_kv : service->meta)
-	{
-		if (!json_object_append(meta_obj, meta_kv.first.c_str(),
-								JSON_VALUE_STRING, meta_kv.second.c_str()))
-			return false;
-	}
-
-	// 添加标签覆盖选项
-	int type = service->tag_override ? JSON_VALUE_TRUE : JSON_VALUE_FALSE;
-	if (!json_object_append(obj, "EnableTagOverride", type))
-		return false;
-
-	// 添加带标签的地址
-	val = json_object_append(obj, "TaggedAddresses", JSON_VALUE_OBJECT);
-	if (!val)
-		return false;
-
-	json_object_t *tagged_obj = json_value_object(val);
-	if (!tagged_obj)
-		return false;
-
-	// 创建所有类型的带标签地址
-	if (!create_tagged_address(service->lan, "lan", tagged_obj))
-		return false;
-
-	if (!create_tagged_address(service->lan_ipv4, "lan_ipv4", tagged_obj))
-		return false;
-
-	if (!create_tagged_address(service->lan_ipv6, "lan_ipv6", tagged_obj))
-		return false;
-
-	if (!create_tagged_address(service->virtual_address, "virtual", tagged_obj))
-		return false;
-
-	if (!create_tagged_address(service->wan, "wan", tagged_obj))
-		return false;
-
-	if (!create_tagged_address(service->wan_ipv4, "wan_ipv4", tagged_obj))
-		return false;
-
-	if (!create_tagged_address(service->wan_ipv6, "wan_ipv6", tagged_obj))
-		return false;
-
-	// 创建健康检查配置
-	if (!create_health_check(config, obj))
-		return false;
-
-	return true; // 服务注册请求创建成功
-}
-
-
-// 解析服务列表结果
-static bool parse_list_service_result(const json_value_t *root,
-									  std::vector<struct ConsulServiceTags>& result)
-{
-	const json_object_t *obj; // 存储 JSON 对象
-	const json_value_t *val;  // 存储 JSON 值
-	const json_array_t *arr;  // 存储 JSON 数组
-	const char *key;          // 存储键
-	const char *str;          // 存储字符串值
-
-	// 将根值转换为 JSON 对象
-	obj = json_value_object(root);
-	if (!obj) // 如果转换失败，返回 false
-		return false;
-
-	// 遍历 JSON 对象中的每个键值对
-	json_object_for_each(key, val, obj)
-	{
-		struct ConsulServiceTags instance; // 定义一个服务标签实例
-
-		instance.service_name = key; // 将键作为服务名称
-		arr = json_value_array(val); // 获取值作为数组
-		if (!arr) // 如果值不是数组，返回 false
-			return false;
-
-		const json_value_t *tag_val; // 遍历数组的每个值
-		json_array_for_each(tag_val, arr)
-		{
-			str = json_value_string(tag_val); // 获取值的字符串形式
-			if (!str) // 如果值不是字符串，返回 false
-				return false;
-
-			instance.tags.emplace_back(str); // 将标签添加到实例
-		}
-
-		result.emplace_back(std::move(instance)); // 将实例添加到结果列表
-	}
-
-	return true; // 返回成功
-}
-
-
-// 解析发现节点信息
-static bool parse_discover_node(const json_object_t *obj,
-								struct ConsulServiceInstance *instance)
-{
-	const json_value_t *val; // 存储 JSON 值
-	const char *str;         // 存储字符串值
-
-	// 查找并解析 "Node" 信息
-	val = json_object_find("Node", obj);
-	if (!val)
-		return false;
-
-	obj = json_value_object(val); // 获取 "Node" 对象
-	if (!obj)
-		return false;
-
-	// 获取 "ID" 字段
-	val = json_object_find("ID", obj);
-	if (!val)
-		return false;
-
-	str = json_value_string(val); // 转换为字符串
-	if (!str)
-		return false;
-
-	instance->node_id = str; // 设置节点 ID
-
-	// 获取 "Node" 字段
-	val = json_object_find("Node", obj);
-	if (!val)
-		return false;
-
-	str = json_value_string(val);
-	if (!str)
-		return false;
-
-	instance->node_name = str; // 设置节点名称
-
-	// 获取 "Address" 字段
-	val = json_object_find("Address", obj);
-	if (!val)
-		return false;
-
-	str = json_value_string(val);
-	if (!str)
-		return false;
-
-	instance->node_address = str; // 设置节点地址
-
-	// 获取 "Datacenter" 字段
-	val = json_object_find("Datacenter", obj);
-	if (!val)
-		return false;
-
-	str = json_value_string(val);
-	if (!str)
-		return false;
-
-	instance->dc = str; // 设置数据中心
-
-	// 解析 "Meta" 信息
-	val = json_object_find("Meta", obj);
-	if (!val)
-		return false;
-
-	const json_object_t *meta_obj = json_value_object(val); // 获取 "Meta" 对象
-	if (!meta_obj)
-		return false;
-
-	const char *meta_k;          // 存储元数据键
-	const json_value_t *meta_v;  // 存储元数据值
-
-	// 遍历 "Meta" 对象
-	json_object_for_each(meta_k, meta_v, meta_obj)
-	{
-		str = json_value_string(meta_v); // 获取元数据值
-		if (!str)
-			return false;
-
-		instance->node_meta[meta_k] = str; // 添加元数据键值对
-	}
-
-	// 获取 "CreateIndex" 字段
-	val = json_object_find("CreateIndex", obj);
-	if (val)
-		instance->create_index = json_value_number(val); // 设置创建索引
-
-	// 获取 "ModifyIndex" 字段
-	val = json_object_find("ModifyIndex", obj);
-	if (val)
-		instance->modify_index = json_value_number(val); // 设置修改索引
-
-	return true; // 返回成功
-}
-
-
-// 解析服务发现结果
-static bool parse_discover_result(const json_value_t *root,
-								  std::vector<struct ConsulServiceInstance>& result)
-{
-	const json_array_t *arr = json_value_array(root); // 获取 JSON 数组
-	const json_value_t *val;  // 存储数组值
-	const json_object_t *obj; // 存储 JSON 对象
-
-	if (!arr) // 如果不是数组，返回 false
-		return false;
-
-	// 遍历数组
-	json_array_for_each(val, arr)
-	{
-		struct ConsulServiceInstance instance; // 创建服务实例
-
-		obj = json_value_object(val); // 获取数组中的对象
-		if (!obj)
-			return false;
-
-		// 解析节点信息
-		if (!parse_discover_node(obj, &instance))
-			return false;
-
-		// 解析服务信息
-		if (!parse_service(obj, &instance.service))
-			return false;
-
-		// 解析健康检查
-		parse_health_check(obj, &instance);
-
-		result.emplace_back(std::move(instance)); // 添加实例到结果列表
-	}
-
-	return true; // 返回成功
-}
-
-
-// 解析服务信息
-static bool parse_service(const json_object_t *obj,
-						  struct ConsulService *service)
-{
-	const json_value_t *val; // 用于存储 JSON 值
-	const char *str;         // 用于存储字符串值
-
-	// 获取 "Service" 对象
-	val = json_object_find("Service", obj);
-	if (!val)
-		return false;
-
-	obj = json_value_object(val); // 将值转换为对象
-	if (!obj)
-		return false;
-
-	// 解析服务 ID
-	val = json_object_find("ID", obj);
-	if (!val)
-		return false;
-
-	str = json_value_string(val); // 将值转换为字符串
-	if (!str)
-		return false;
-
-	service->service_id = str; // 设置服务 ID
-
-	// 解析服务名称
-	val = json_object_find("Service", obj);
-	if (!val)
-		return false;
-
-	str = json_value_string(val);
-	if (!str)
-		return false;
-
-	service->service_name = str; // 设置服务名称
-
-	// 解析命名空间
-	val = json_object_find("Namespace", obj);
-	if (val)
-	{
-		str = json_value_string(val);
-		if (!str)
-			return false;
-
-		service->service_namespace = str; // 设置命名空间
-	}
-
-	// 解析服务地址
-	val = json_object_find("Address", obj);
-	if (!val)
-		return false;
-
-	str = json_value_string(val);
-	if (!str)
-		return false;
-
-	service->service_address.first = str; // 设置服务地址
-
-	// 解析服务端口
-	val = json_object_find("Port", obj);
-	if (!val)
-		return false;
-
-	service->service_address.second = json_value_number(val); // 设置服务端口
-
-	// 解析带标签地址
-	val = json_object_find("TaggedAddresses", obj);
-	if (!val)
-		return false;
-
-	parse_tagged_address("lan", val, service->lan);
-	parse_tagged_address("lan_ipv4", val, service->lan_ipv4);
-	parse_tagged_address("lan_ipv6", val, service->lan_ipv6);
-	parse_tagged_address("virtual", val, service->virtual_address);
-	parse_tagged_address("wan", val, service->wan);
-	parse_tagged_address("wan_ipv4", val, service->wan_ipv4);
-	parse_tagged_address("wan_ipv6", val, service->wan_ipv6);
-
-	// 解析标签列表
-	val = json_object_find("Tags", obj);
-	if (!val)
-		return false;
-
-	const json_array_t *tags_arr = json_value_array(val); // 获取数组
-	if (tags_arr)
-	{
-		const json_value_t *tags_value;
-		json_array_for_each(tags_value, tags_arr) // 遍历数组
-		{
-			str = json_value_string(tags_value); // 获取标签字符串
-			if (!str)
-				return false;
-
-			service->tags.emplace_back(str); // 添加标签到服务
-		}
-	}
-
-	// 解析元数据
-	val = json_object_find("Meta", obj);
-	if (!val)
-		return false;
-
-	const json_object_t *meta_obj = json_value_object(val); // 获取元数据对象
-	if (!meta_obj)
-		return false;
-
-	const char *meta_k;
-	const json_value_t *meta_v;
-	json_object_for_each(meta_k, meta_v, meta_obj) // 遍历元数据
-	{
-		str = json_value_string(meta_v);
-		if (!str)
-			return false;
-
-		service->meta[meta_k] = str; // 添加元数据键值对
-	}
-
-	// 检查标签覆盖选项
-	val = json_object_find("EnableTagOverride", obj);
-	if (val)
-		service->tag_override = (json_value_type(val) == JSON_VALUE_TRUE);
-
-	return true; // 返回成功
-}
-
-
-// 解析健康检查信息
-static bool parse_health_check(const json_object_t *obj,
-							   struct ConsulServiceInstance *instance)
-{
-	const json_value_t *val; // 存储 JSON 值
-	const char *str;         // 存储字符串值
-
-	// 获取 "Checks" 数组
-	val = json_object_find("Checks", obj);
-	if (!val)
-		return false;
-
-	const json_array_t *check_arr = json_value_array(val); // 转换为数组
-	if (!check_arr)
-		return false;
-
-	const json_value_t *arr_val;
-	json_array_for_each(arr_val, check_arr) // 遍历数组
-	{
-		obj = json_value_object(arr_val); // 获取数组中的对象
-		if (!obj)
-			return false;
-
-		// 解析服务名称
-		val = json_object_find("ServiceName", obj);
-		if (!val)
-			return false;
-
-		str = json_value_string(val);
-		if (!str)
-			return false;
-
-		std::string check_service_name = str;
-
-		// 解析服务 ID
-		val = json_object_find("ServiceID", obj);
-		if (!val)
-			return false;
-
-		str = json_value_string(val);
-		if (!str)
-			return false;
-
-		std::string check_service_id = str;
-		if (check_service_id.empty() || check_service_name.empty())
-			continue;
-
-		// 解析检查 ID
-		val = json_object_find("CheckID", obj);
-		if (!val)
-			return false;
-
-		str = json_value_string(val);
-		if (!str)
-			return false;
-
-		instance->check_id = str;
-
-		// 解析检查名称
-		val = json_object_find("Name", obj);
-		if (!val)
-			return false;
-
-		str = json_value_string(val);
-		if (!str)
-			return false;
-
-		instance->check_name = str;
-
-		// 解析检查状态
-		val = json_object_find("Status", obj);
-		if (!val)
-			return false;
-
-		str = json_value_string(val);
-		if (!str)
-			return false;
-
-		instance->check_status = str;
-
-		// 解析备注
-		val = json_object_find("Notes", obj);
-		if (val)
-		{
-			str = json_value_string(val);
-			if (!str)
-				return false;
-
-			instance->check_notes = str;
-		}
-
-		// 解析输出
-		val = json_object_find("Output", obj);
-		if (val)
-		{
-			str = json_value_string(val);
-			if (!str)
-				return false;
-
-			instance->check_output = str;
-		}
-
-		// 解析检查类型
-		val = json_object_find("Type", obj);
-		if (val)
-		{
-			str = json_value_string(val);
-			if (!str)
-				return false;
-
-			instance->check_type = str;
-		}
-
-		break; // 只解析一个有效的健康检查
-	}
-
-	return true; // 返回成功
-}
-
-// 解析服务发现结果
-static bool parse_discover_result(const json_value_t *root,
-								  std::vector<struct ConsulServiceInstance>& result)
-{
-	const json_array_t *arr = json_value_array(root); // 转换为数组
-	const json_value_t *val;  // 存储数组中的值
-	const json_object_t *obj; // 存储 JSON 对象
-
-	if (!arr)
-		return false;
-
-	// 遍历数组
-	json_array_for_each(val, arr)
-	{
-		struct ConsulServiceInstance instance; // 定义服务实例
-
-		obj = json_value_object(val); // 获取数组中的对象
-		if (!obj)
-			return false;
-
-		// 解析节点信息
-		if (!parse_discover_node(obj, &instance))
-			return false;
-
-		// 解析服务信息
-		if (!parse_service(obj, &instance.service))
-			return false;
-
-		// 解析健康检查
-		parse_health_check(obj, &instance);
-
-		result.emplace_back(std::move(instance)); // 添加实例到结果
-	}
-
-	return true; // 返回成功
-}
-
-
-// 打印 JSON 对象，递归地将其转换为字符串格式
-static void print_json_object(const json_object_t *obj, int depth,
-							  std::string& json_str)
-{
-	const char *name;          // JSON 对象的键
-	const json_value_t *val;   // JSON 对象的值
-	int n = 0;                 // 键值对的计数器
-	int i;
-
-	json_str += "{\n";         // 开始对象
-
-	// 遍历 JSON 对象中的每个键值对
-	json_object_for_each(name, val, obj)
-	{
-		if (n != 0)            // 如果不是第一个键值对，添加逗号换行
-			json_str += ",\n";
-
-		n++;                   // 键值对计数加 1
-		for (i = 0; i < depth + 1; i++) // 根据深度添加缩进
-			json_str += "    ";
-
-		// 添加键
-		json_str += "\"";
-		json_str += name;
-		json_str += "\": ";
-
-		// 递归打印值
-		print_json_value(val, depth + 1, json_str);
-	}
-
-	json_str += "\n";          // 对象内容结束
-	for (i = 0; i < depth; i++) // 根据深度添加缩进
-		json_str += "    ";
-
-	json_str += "}";           // 结束对象
-}
-
-
-// 打印 JSON 数组，递归地将其转换为字符串格式
-static void print_json_array(const json_array_t *arr, int depth,
-							 std::string& json_str)
-{
-	const json_value_t *val;   // JSON 数组的值
-	int n = 0;                 // 数组值的计数器
-	int i;
-
-	json_str += "[\n";         // 开始数组
-
-	// 遍历 JSON 数组中的每个值
-	json_array_for_each(val, arr)
-	{
-		if (n != 0)            // 如果不是第一个值，添加逗号换行
-			json_str += ",\n";
-
-		n++;                   // 值计数加 1
-		for (i = 0; i < depth + 1; i++) // 根据深度添加缩进
-			json_str += "    ";
-
-		// 递归打印值
-		print_json_value(val, depth + 1, json_str);
-	}
-
-	json_str += "\n";          // 数组内容结束
-	for (i = 0; i < depth; i++) // 根据深度添加缩进
-		json_str += "    ";
-
-	json_str += "]";           // 结束数组
-}
-
-
-// 打印 JSON 字符串，处理特殊字符转义
-static void print_json_string(const char *str, std::string& json_str)
-{
-	json_str += "\"";          // 开始字符串
-
-	// 遍历字符串中的每个字符
-	while (*str)
-	{
-		switch (*str)
-		{
-		case '\r':             // 回车符转义
-			json_str += "\\r";
-			break;
-		case '\n':             // 换行符转义
-			json_str += "\\n";
-			break;
-		case '\f':             // 换页符转义
-			json_str += "\\f";
-			break;
-		case '\b':             // 退格符转义
-			json_str += "\\b";
-			break;
-		case '\"':             // 双引号转义
-			json_str += "\\\"";
-			break;
-		case '\t':             // 制表符转义
-			json_str += "\\t";
-			break;
-		case '\\':             // 反斜杠转义
-			json_str += "\\\\";
-			break;
-		default:               // 其他字符直接添加
-			json_str += *str;
-			break;
-		}
-		str++;                 // 指向下一个字符
-	}
-	json_str += "\"";          // 结束字符串
-}
-
-
-// 打印 JSON 数字
-static void print_json_number(double number, std::string& json_str)
-{
-	long long integer = number; // 检查数字是否是整数
-
-	if (integer == number)      // 如果是整数
-		json_str += std::to_string(integer); // 转换为整数字符串
-	else                        // 如果是浮点数
-		json_str += std::to_string(number); // 转换为浮点数字符串
-}
-
-
-// 根据值的类型打印 JSON 值
-static void print_json_value(const json_value_t *val, int depth,
-							 std::string& json_str)
-{
-	switch (json_value_type(val)) // 获取值的类型
-	{
-	case JSON_VALUE_STRING:       // 如果是字符串
-		print_json_string(json_value_string(val), json_str);
-		break;
-	case JSON_VALUE_NUMBER:       // 如果是数字
-		print_json_number(json_value_number(val), json_str);
-		break;
-	case JSON_VALUE_OBJECT:       // 如果是对象
-		print_json_object(json_value_object(val), depth, json_str);
-		break;
-	case JSON_VALUE_ARRAY:        // 如果是数组
-		print_json_array(json_value_array(val), depth, json_str);
-		break;
-	case JSON_VALUE_TRUE:         // 如果是布尔值 true
-		json_str += "true";
-		break;
-	case JSON_VALUE_FALSE:        // 如果是布尔值 false
-		json_str += "false";
-		break;
-	case JSON_VALUE_NULL:         // 如果是 null
-		json_str += "null";
-		break;
-	}
-}
-