feat(discover): redesign to stateless parameter-driven architecture (v1.0.10) (by AI)

.gitignore

@@ -0,0 +1 @@
+.log.meta.json

AppClient.go

@@ -8,58 +8,64 @@ import (
 
 // AppClient 用于管理单个请求的重试和负载均衡状态
 type AppClient struct {
-	excludes map[string]bool
-	tryTimes int
-	Logger   *log.Logger
-	App      string
-	Method   string
-	Path     string
-	Data     *map[string]any
-	Headers  *map[string]string
+	discoverer *Discoverer
+	excludes   map[string]bool // 本次请求已排除的节点
+	attempts   int             // 本次请求的重试次数
+	Logger     *log.Logger     // 用于日志记录的 Logger
+	App        string          // 目标应用名称
+	Method     string          // 请求方法
+	Path       string          // 请求路径
+	Data       map[string]any  // 请求数据
+	Headers    map[string]string // 请求头
 }
 
-func (ac *AppClient) logError(error string, extra ...any) {
+// logError 记录 Discover 客户端错误
+func (ac *AppClient) logError(msg string, extra ...any) {
 	if ac.Logger == nil {
 		ac.Logger = log.DefaultLogger
 	}
-	ac.Logger.Error("Discover Client: "+error, extra...)
+	ac.Logger.Error("Discover Client: "+msg, extra...)
 }
 
+// Next 获取下一个可用节点
 func (ac *AppClient) Next(app string, request *http.Request) *NodeInfo {
+	
 	return ac.NextWithNode(app, "", request)
 }
 
+// CheckApp 检查并尝试添加应用
 func (ac *AppClient) CheckApp(app string) bool {
-	nodes := getAppNodes(app)
+	nodes := ac.discoverer.GetAppNodes(app)
 	if nodes == nil {
-		if !addApp(app, "", true) {
-			ac.logError("app not found", "app", app, "calls", Config.Calls)
+		if !ac.discoverer.AddExternalApp(app, CallConfig{}) {
+			ac.logError("app not found", "app", app, "calls", ac.discoverer.config.Calls)
 			return false
 		}
 	}
 	return true
 }
 
+// NextWithNode 获取下一个可用节点，支持指定节点
 func (ac *AppClient) NextWithNode(app, withNode string, request *http.Request) *NodeInfo {
 	if ac.excludes == nil {
 		ac.excludes = make(map[string]bool)
 	}
 
-	allNodes := getAppNodes(app)
+	allNodes := ac.discoverer.GetAppNodes(app)
 	if len(allNodes) == 0 {
 		ac.logError("node not found", "app", app)
 		return nil
 	}
 
-	ac.tryTimes++
+	ac.attempts++
 	if withNode != "" {
 		ac.excludes[withNode] = true
 		return allNodes[withNode]
 	}
 
-	readyNodes := make([]*NodeInfo, 0)
+	readyNodes := make([]*NodeInfo, 0, len(allNodes))
 	for _, node := range allNodes {
-		if ac.excludes[node.Addr] || node.FailedTimes >= Config.CallRetryTimes {
+		if ac.excludes[node.Addr] || node.FailedTimes.Load() >= int32(ac.discoverer.config.CallRetryTimes) {
 			continue
 		}
 		readyNodes = append(readyNodes, node)
@@ -76,14 +82,14 @@ func (ac *AppClient) NextWithNode(app, withNode string, request *http.Request) *
 
 	var node *NodeInfo
 	if len(readyNodes) > 0 {
-		node = settedLoadBalancer.Next(ac, readyNodes, request)
+		node = ac.discoverer.settedLoadBalancer.Next(ac, readyNodes, request)
 		if node != nil {
 			ac.excludes[node.Addr] = true
 		}
 	}
 
 	if node == nil {
-		ac.logError("no available node", "app", app, "tryTimes", ac.tryTimes)
+		ac.logError("no available node", "app", app, "attempts", ac.attempts)
 	}
 
 	return node

CHANGELOG.md

@@ -1,9 +1,48 @@
 # CHANGELOG
 
+## v1.0.10 (2026-05-09)
+- **API Redesign (Elegant API)**:
+  - 引入包级泛型便捷调用：`Get[T]`, `Post[T]`, `Put[T]`, `Delete[T]`。
+  - 引入 `From(r *http.Request)` 包装器，优雅实现微服务 Header 自动透传。
+  - 统一 API 入口，区分服务端（`Start`/`Stop`）与客户端（`Get`/`Post`/`Do`）模式。
+  - 移除晦涩的 `CallT` 泛型辅助函数。
+  - 增加 `SetApp`, `SetRegistry`, `SetWeight` 便捷配置接口。
+- **Infrastructure Alignment**:
+  - 耗时统计切换至 `go/timer` 高性能引擎。
+  - 服务令牌（Token）采用 `go/safe.SafeBuf` 内存安全保护。
+  - 依赖更新：`go/http` 升级至 `v1.0.10`。
+- **Stability**:
+  - 优化 `Stop()` 逻辑：彻底重置实例状态，支持在单进程多次启动/停止（如单元测试场景）。
+  - 优化 `Init()` 逻辑：支持程序化配置与文件配置的智能合并。
+  - 修复 `AddExternalApp` 可能导致的订阅死锁问题。
+
+## v1.0.9 (2026-05-05)
+- **Stability & Testing**:
+  - 修复 `AddExternalApp` 在新客户端场景下可能遗漏同步拉取节点的问题。
+  - 优化测试用例性能：将 Mock Server 默认超时导致的 100s 阻塞通过强制 HTTP/1.1 配置解决。
+  - 增强测试健壮性：全面改用动态端口（Port 0）避开冲突，并利用 Redis URL 唯一 ID 隔离多实例间的 PubSub 干扰。
+  - 改进守护进程退出逻辑：使用 `select` 非阻塞模式确保 `Stop()` 后能立即响应并优雅关闭。
+
+## v1.0.4 (2026-05-05)
+- 稳定性增强：在 `addApp` 中引入“写时复制”（Copy-on-Write）机制，通过对配置 Map 进行深拷贝，彻底消除了高并发下配置读取与修改导致的 `concurrent map read and map write` 崩溃风险。
+- 状态一致性优化：确保默认实例在动态添加应用后，能够同步更新包级别的全局 `Config` 变量，保证业务代码通过不同路径读取配置的一致性。
+
+## v1.0.3 (2026-05-05)
+- 架构深度优化：将 HTTP 客户端连接池（`appClientPools`）移入 `Discoverer` 实例，实现完全的资源隔离。
+- 并发安全增强：引入读写锁保护 `Config` 结构，防止高并发下的配置读写冲突。
+- 生命周期管理优化：使用 `atomic.Bool` 管理 `daemonRunning` 状态，确保线程安全。
+- 资源回收机制：在 `Stop()` 方法中新增 HTTP 连接池清理逻辑（调用 `Destroy` 释放闲置连接），防止内存与句柄泄漏。
+- 接口严谨性：将 `Discoverer` 内部字段（如 `config`）设为私有，通过 `GetConfig`/`SetConfig` 统一访问。
+
+## v1.0.2
+- 架构重构：支持多 Discoverer 实例，消灭包级全局状态。
+- 兼容性：保留包级 API 转发至 `DefaultDiscoverer`。
+
+## v1.0.1
+- 优化代码规范：修复变量名冲突，改进命名语义。
+- 性能优化：优化 `AppClient` 类型，减少寻址开销。
+- 故障隔离：实现本地隔离机制，不再篡跨全局 Redis 状态。
+- 压力缓解：心跳间隔优化至 5 秒。
+
 ## v1.0.0
-- 从 `ssgo/discover` 迁移至 `apigo.cc/go/discover`。
-- 采用全新的 `apigo.cc/go` 基础设施（log, redis, http, cast, u）。
-- 优化了注册中心同步机制，使用 `redis.Subscribe` 简化 PubSub 处理。
-- 增强了负载均衡算法，引入更精确的得分计算。
-- 统一了 Header 定义，对齐 `go/http` 标准。
-- 移除所有 `panic`，通过 `error` 返回和日志记录确保系统稳定性。
+- 初始版本：从 `ssgo/discover` 迁移并重构。

Caller.go

@@ -5,29 +5,26 @@ import (
 	"net/http"
 	"reflect"
 	"strings"
-	"sync"
 	"time"
 
 	"github.com/gorilla/websocket"
 	"apigo.cc/go/cast"
 	gohttp "apigo.cc/go/http"
 	"apigo.cc/go/log"
+	"apigo.cc/go/timer"
 )
 
-var appClientPools = make(map[string]*gohttp.Client)
-var appClientPoolsLock sync.RWMutex
-
-func getHttpClient(app string, timeout time.Duration, h2c bool) *gohttp.Client {
-	appClientPoolsLock.RLock()
-	c := appClientPools[app]
-	appClientPoolsLock.RUnlock()
+func (d *Discoverer) getHttpClient(app string, timeout time.Duration, h2c bool) *gohttp.Client {
+	d.appClientPoolsLock.RLock()
+	c := d.appClientPools[app]
+	d.appClientPoolsLock.RUnlock()
 	if c != nil {
 		return c
 	}
 
-	appClientPoolsLock.Lock()
-	defer appClientPoolsLock.Unlock()
-	c = appClientPools[app]
+	d.appClientPoolsLock.Lock()
+	defer d.appClientPoolsLock.Unlock()
+	c = d.appClientPools[app]
 	if c != nil {
 		return c
 	}
@@ -37,52 +34,101 @@ func getHttpClient(app string, timeout time.Duration, h2c bool) *gohttp.Client {
 	} else {
 		c = gohttp.NewClient(timeout)
 	}
-	appClientPools[app] = c
+	d.appClientPools[app] = c
 	return c
 }
 
+// Caller 用于发起服务间调用
 type Caller struct {
-	Request *http.Request
-	NoBody  bool
-	logger  *log.Logger
+	discoverer *Discoverer
+	Request    *http.Request // 原始请求，用于透传 Header
+	NoBody     bool          // 是否不发送请求体
+	logger     *log.Logger   // 用于日志记录的 Logger
 }
 
-func NewCaller(request *http.Request, logger *log.Logger) *Caller {
-	return &Caller{Request: request, logger: logger}
+func (d *Discoverer) From(request *http.Request) *Caller {
+	return &Caller{discoverer: d, Request: request, logger: d.logger}
 }
 
-func (c *Caller) logError(error string, extra ...any) {
+func (d *Discoverer) NewCaller(request *http.Request, logger *log.Logger) *Caller {
+	return &Caller{discoverer: d, Request: request, logger: logger}
+}
+
+// logError 记录 Discover 调用器错误
+func (c *Caller) logError(msg string, extra ...any) {
 	if c.logger == nil {
 		c.logger = log.DefaultLogger
 	}
-	c.logger.Error("Discover Caller: "+error, extra...)
+	c.logger.Error("Discover Caller: "+msg, extra...)
 }
 
+// Get 发起 GET 请求
 func (c *Caller) Get(app, path string, headers ...string) *gohttp.Result {
 	return c.Do("GET", app, path, nil, headers...)
 }
 
+// Post 发起 POST 请求
 func (c *Caller) Post(app, path string, data any, headers ...string) *gohttp.Result {
 	return c.Do("POST", app, path, data, headers...)
 }
 
+// Put 发起 PUT 请求
 func (c *Caller) Put(app, path string, data any, headers ...string) *gohttp.Result {
 	return c.Do("PUT", app, path, data, headers...)
 }
 
+// Delete 发起 DELETE 请求
 func (c *Caller) Delete(app, path string, data any, headers ...string) *gohttp.Result {
 	return c.Do("DELETE", app, path, data, headers...)
 }
 
+// Head 发起 HEAD 请求
 func (c *Caller) Head(app, path string, headers ...string) *gohttp.Result {
 	return c.Do("HEAD", app, path, nil, headers...)
 }
 
+// Get 发起 GET 请求
+func (d *Discoverer) Get(app, path string, headers ...string) *gohttp.Result {
+	return d.NewCaller(nil, nil).Get(app, path, headers...)
+}
+
+// Post 发起 POST 请求
+func (d *Discoverer) Post(app, path string, data any, headers ...string) *gohttp.Result {
+	return d.NewCaller(nil, nil).Post(app, path, data, headers...)
+}
+
+// Put 发起 PUT 请求
+func (d *Discoverer) Put(app, path string, data any, headers ...string) *gohttp.Result {
+	return d.NewCaller(nil, nil).Put(app, path, data, headers...)
+}
+
+// Delete 发起 DELETE 请求
+func (d *Discoverer) Delete(app, path string, data any, headers ...string) *gohttp.Result {
+	return d.NewCaller(nil, nil).Delete(app, path, data, headers...)
+}
+
+// Head 发起 HEAD 请求
+func (d *Discoverer) Head(app, path string, headers ...string) *gohttp.Result {
+	return d.NewCaller(nil, nil).Head(app, path, headers...)
+}
+
+// Do 发起通用请求
+func (d *Discoverer) Do(method, app, path string, data any, headers ...string) *gohttp.Result {
+	return d.NewCaller(nil, nil).Do(method, app, path, data, headers...)
+}
+
+// Open 发起 WebSocket 连接
+func (d *Discoverer) Open(app, path string, headers ...string) *websocket.Conn {
+	return d.NewCaller(nil, nil).Open(app, path, headers...)
+}
+
+// Do 发起通用请求
 func (c *Caller) Do(method, app, path string, data any, headers ...string) *gohttp.Result {
 	r, _ := c.DoWithNode(method, app, "", path, data, headers...)
 	return r
 }
 
+// Open 发起 WebSocket 连接
 func (c *Caller) Open(app, path string, headers ...string) *websocket.Conn {
 	r, _ := c.doWithNode(false, "WS", app, "", path, nil, headers...)
 	if v, ok := r.(*websocket.Conn); ok {
@@ -91,6 +137,7 @@ func (c *Caller) Open(app, path string, headers ...string) *websocket.Conn {
 	return nil
 }
 
+// DoWithNode 发起请求并返回结果及节点地址
 func (c *Caller) DoWithNode(method, app, withNode, path string, data any, headers ...string) (*gohttp.Result, string) {
 	r, nodeAddr := c.doWithNode(false, method, app, withNode, path, data, headers...)
 	if v, ok := r.(*gohttp.Result); ok {
@@ -99,6 +146,7 @@ func (c *Caller) DoWithNode(method, app, withNode, path string, data any, header
 	return nil, nodeAddr
 }
 
+// ManualDoWithNode 发起请求（手动处理响应）并返回结果及节点地址
 func (c *Caller) ManualDoWithNode(method, app, withNode, path string, data any, headers ...string) (*gohttp.Result, string) {
 	r, nodeAddr := c.doWithNode(true, method, app, withNode, path, data, headers...)
 	if v, ok := r.(*gohttp.Result); ok {
@@ -107,15 +155,15 @@ func (c *Caller) ManualDoWithNode(method, app, withNode, path string, data any,
 	return nil, nodeAddr
 }
 
-func (c *Caller) doWithNode(manualDo bool, method, app, withNode, path string, data any, headers ...string) (any, string) {
+func (c *Caller) doWithNode(manual bool, method, app, withNode, path string, data any, headers ...string) (any, string) {
 	callerHeaders := make(map[string]string)
 	for i := 1; i < len(headers); i += 2 {
 		callerHeaders[headers[i-1]] = headers[i]
 	}
 
-	if isServer {
-		callerHeaders[HeaderFromApp] = Config.App
-		callerHeaders[HeaderFromNode] = myAddr
+	if c.discoverer.isServer {
+		callerHeaders[HeaderFromApp] = c.discoverer.app
+		callerHeaders[HeaderFromNode] = c.discoverer.myAddr
 	}
 
 	callData := make(map[string]any)
@@ -127,16 +175,17 @@ func (c *Caller) doWithNode(manualDo bool, method, app, withNode, path string, d
 	}
 
 	appClient := AppClient{
-		Logger:  c.logger,
-		App:     app,
-		Method:  method,
-		Path:    path,
-		Data:    &callData,
-		Headers: &callerHeaders,
+		discoverer: c.discoverer,
+		Logger:     c.logger,
+		App:        app,
+		Method:     method,
+		Path:       path,
+		Data:       callData,
+		Headers:    callerHeaders,
 	}
 
-	if settedRoute != nil {
-		settedRoute(&appClient, c.Request)
+	if c.discoverer.settedRoute != nil {
+		c.discoverer.settedRoute(&appClient, c.Request)
 		app = appClient.App
 		method = appClient.Method
 		path = appClient.Path
@@ -146,9 +195,11 @@ func (c *Caller) doWithNode(manualDo bool, method, app, withNode, path string, d
 		return &gohttp.Result{Error: fmt.Errorf("app %s not found", app)}, ""
 	}
 
-	callInfo := getCallInfo(app)
-	if callInfo != nil && callInfo.Token != "" {
-		callerHeaders["Access-Token"] = callInfo.Token
+	callInfo, hasCallInfo := c.discoverer.getCallInfo(app)
+	if hasCallInfo && callInfo.Token != nil {
+		tk := callInfo.Token.Open()
+		callerHeaders["Access-Token"] = tk.String()
+		tk.Close()
 	}
 
 	settedHeaders := make([]string, 0, len(callerHeaders)*2)
@@ -162,14 +213,23 @@ func (c *Caller) doWithNode(manualDo bool, method, app, withNode, path string, d
 			break
 		}
 
-		node.UsedTimes++
-		startTime := time.Now()
+		node.UsedTimes.Add(1)
+		tracker := timer.Start()
 		scheme := "http"
-		if callInfo != nil && callInfo.SSL {
+		if hasCallInfo && callInfo.SSL {
 			scheme = "https"
 		}
 
-		hc := getHttpClient(app, callInfo.Timeout, callInfo.HttpVersion == 2 && !callInfo.SSL)
+		timeout := 10 * time.Second
+		h2c := false
+		if hasCallInfo {
+			if callInfo.Timeout > 0 {
+				timeout = callInfo.Timeout
+			}
+			h2c = callInfo.Http2 && !callInfo.SSL
+		}
+
+		hc := c.discoverer.getHttpClient(app, timeout, h2c)
 		hc.NoBody = c.NoBody
 
 		var res *gohttp.Result
@@ -194,13 +254,13 @@ func (c *Caller) doWithNode(manualDo bool, method, app, withNode, path string, d
 			res = &gohttp.Result{Error: err, Response: resp}
 		} else {
 			if c.Request != nil {
-				if manualDo {
+				if manual {
 					res = hc.ManualDoByRequest(c.Request, method, url, data, settedHeaders...)
 				} else {
 					res = hc.DoByRequest(c.Request, method, url, data, settedHeaders...)
 				}
 			} else {
-				if manualDo {
+				if manual {
 					res = hc.ManualDo(method, url, data, settedHeaders...)
 				} else {
 					res = hc.Do(method, url, data, settedHeaders...)
@@ -208,11 +268,12 @@ func (c *Caller) doWithNode(manualDo bool, method, app, withNode, path string, d
 			}
 		}
 
-		responseTime := time.Since(startTime)
-		settedLoadBalancer.Response(&appClient, node, res.Error, res.Response, responseTime)
+		responseTime := tracker.Record("call")
+		usedTimeMs := float32(responseTime.Nanoseconds()) / 1e6
+		c.discoverer.settedLoadBalancer.Response(&appClient, node, res.Error, res.Response, responseTime)
 
 		if res.Error != nil || (res.Response != nil && res.Response.StatusCode >= 502 && res.Response.StatusCode <= 504) {
-			node.FailedTimes++
+			node.FailedTimes.Add(1)
 			errStr := ""
 			if res.Error != nil {
 				errStr = res.Error.Error()
@@ -220,18 +281,17 @@ func (c *Caller) doWithNode(manualDo bool, method, app, withNode, path string, d
 				errStr = res.Response.Status
 			}
 
-			c.logError(errStr, "app", app, "node", node.Addr, "path", path, "tryTimes", appClient.tryTimes)
+			c.logError(errStr, "app", app, "node", node.Addr, "path", path, "attempts", appClient.attempts)
+			appClient.Log(node.Addr, usedTimeMs, fmt.Errorf("%s", errStr))
 
-			if node.FailedTimes >= Config.CallRetryTimes {
-				logError("node removed due to high failures", "app", app, "node", node.Addr)
-				if clientRedisPool != nil {
-					clientRedisPool.Do("HDEL", app, node.Addr)
-					clientRedisPool.PUBLISH("CH_"+app, fmt.Sprintf("%s 0", node.Addr))
-				}
+			if node.FailedTimes.Load() >= int32(c.discoverer.config.CallRetryTimes) {
+				c.discoverer.logError("node isolated locally due to high failures", "app", app, "node", node.Addr)
 			}
 			continue
 		}
 
+		node.FailedTimes.Store(0)
+		appClient.Log(node.Addr, usedTimeMs, nil)
 		if strings.ToUpper(method) == "WS" {
 			return wsConn, node.Addr
 		}
@@ -240,3 +300,4 @@ func (c *Caller) doWithNode(manualDo bool, method, app, withNode, path string, d
 
 	return &gohttp.Result{Error: fmt.Errorf("all nodes failed for %s %s", app, path)}, ""
 }
+

Config.go

@@ -1,14 +1,21 @@
 package discover
 
-// Config 存储发现服务的全局配置
-var Config = struct {
-	Registry       string            // 注册中心地址，如 redis://:@127.0.0.1:6379/15
-	App            string            // 当前应用名称
-	Weight         int               // 权重，默认为 100
-	Calls          map[string]string // 调用的应用列表及其配置
-	CallRetryTimes int               // 调用重试次数
-	IpPrefix       string            // 指定使用的 IP 网段
-}{
-	Weight:         100,
-	CallRetryTimes: 10,
+import (
+	"time"
+	"apigo.cc/go/safe"
+)
+
+// CallConfig 下游服务调用配置
+type CallConfig struct {
+	Timeout time.Duration    // 请求超时时间
+	Token   *safe.SafeBuf    // 访问凭证 (必须安全存储)
+	Http2   bool             // 是否强制使用 HTTP/2 (H2C/H2)
+	SSL     bool             // 是否使用 HTTPS/WSS
+}
+
+// Config 存储发现服务的可选配置
+type Config struct {
+	Weight         int                    // 权重，默认为 100
+	Calls          map[string]CallConfig  // 调用的应用列表及其配置
+	CallRetryTimes int                    // 调用重试次数
 }

Constants.go

@@ -1,35 +1,27 @@
 package discover
 
-const (
-	HeaderFromApp  = "X-Discover-From-App"
-	HeaderFromNode = "X-Discover-From-Node"
-
-	HeaderClientIp         = "X-Client-Ip"
-	HeaderForwardedFor     = "X-Forwarded-For"
-	HeaderUserId           = "X-User-Id"
-	HeaderDeviceId         = "X-Device-Id"
-	HeaderClientAppName    = "X-Client-App-Name"
-	HeaderClientAppVersion = "X-Client-App-Version"
-	HeaderSessionId        = "X-Session-Id"
-	HeaderRequestId        = "X-Request-Id"
-	HeaderHost             = "X-Host"
-	HeaderScheme           = "X-Scheme"
-	HeaderUserAgent        = "User-Agent"
+import (
+	gohttp "apigo.cc/go/http"
 )
 
-var RelayHeaders = []string{
-	HeaderClientIp,
-	HeaderForwardedFor,
-	HeaderUserId,
-	HeaderDeviceId,
-	HeaderClientAppName,
-	HeaderClientAppVersion,
-	HeaderSessionId,
-	HeaderRequestId,
-	HeaderHost,
-	HeaderScheme,
-	HeaderUserAgent,
-}
+const (
+	HeaderFromApp  = gohttp.HeaderFromApp
+	HeaderFromNode = gohttp.HeaderFromNode
+
+	HeaderClientIP         = gohttp.HeaderClientIP
+	HeaderForwardedFor     = gohttp.HeaderForwardedFor
+	HeaderUserID           = gohttp.HeaderUserID
+	HeaderDeviceID         = gohttp.HeaderDeviceID
+	HeaderClientAppName    = gohttp.HeaderClientAppName
+	HeaderClientAppVersion = gohttp.HeaderClientAppVersion
+	HeaderSessionID        = gohttp.HeaderSessionID
+	HeaderRequestID        = gohttp.HeaderRequestID
+	HeaderHost             = gohttp.HeaderHost
+	HeaderScheme           = gohttp.HeaderScheme
+	HeaderUserAgent        = gohttp.HeaderUserAgent
+)
+
+var RelayHeaders = gohttp.RelayHeaders
 
 const DefaultRegistry = "127.0.0.1:6379::15"
 const EnvRegistry = "DISCOVER_REGISTRY"

Discover.go

@@ -2,183 +2,223 @@ package discover
 
 import (
 	"fmt"
-	"net"
 	"net/http"
-	"os"
-	"os/signal"
-	"regexp"
 	"strings"
 	"sync"
-	"syscall"
+	"sync/atomic"
 	"time"
 
 	"apigo.cc/go/cast"
-	"apigo.cc/go/config"
+	gohttp "apigo.cc/go/http"
 	"apigo.cc/go/id"
 	"apigo.cc/go/log"
 	"apigo.cc/go/redis"
 )
 
-var (
+// Discoverer 发现服务实例
+type Discoverer struct {
+	config Config
+	registry string
+	app string
+	
 	serverRedisPool *redis.Redis
 	clientRedisPool *redis.Redis
 	pubsubRedisPool *redis.Redis
-	isServer        = false
-	isClient        = false
-	daemonRunning   = false
-	myAddr          = ""
-	_logger         = log.DefaultLogger
-	_inited         = false
+	isServer        bool
+	isClient        bool
+	daemonRunning      atomic.Bool
+	myAddr             string
+	logger             *log.Logger
+		daemonStopSignal   chan struct{}
+	daemonDoneSignal   chan struct{}
+	appLock            sync.RWMutex
+	calls          map[string]CallConfig
+	appNodes       map[string]map[string]*NodeInfo
+	appSubscribed  map[string]bool
 
-	daemonStopChan chan bool
-	appLock        sync.RWMutex
-	_calls         = map[string]*callInfoType{}
-	_appNodes      = map[string]map[string]*NodeInfo{}
-	appSubscribed  = map[string]bool{}
+	appClientPools     map[string]*gohttp.Client
+	appClientPoolsLock sync.RWMutex
 
-	settedRoute        func(*AppClient, *http.Request) = nil
-	settedLoadBalancer LoadBalancer                    = &DefaultLoadBalancer{}
-)
-
-type callInfoType struct {
-	Timeout     time.Duration
-	HttpVersion int
-	Token       string
-	SSL         bool
+	settedRoute        func(*AppClient, *http.Request)
+	settedLoadBalancer LoadBalancer
 }
 
-func IsServer() bool { return isServer }
-func IsClient() bool { return isClient }
 
-func logError(error string, extra ...any) {
-	_logger.Error("Discover: "+error, append(extra, "app", Config.App, "addr", myAddr)...)
+
+
+// IsServer 返回当前节点是否作为服务端运行
+func (d *Discoverer) IsServer() bool { return d.isServer }
+
+// IsClient 返回当前节点是否作为客户端运行
+func (d *Discoverer) IsClient() bool { return d.isClient }
+
+func (d *Discoverer) logError(msg string, extra ...any) {
+	d.logger.Error("Discover: "+msg, append(extra, "app", d.app, "addr", d.myAddr)...)
 }
 
-func logInfo(info string, extra ...any) {
-	_logger.Info("Discover: "+info, append(extra, "app", Config.App, "addr", myAddr)...)
+func (d *Discoverer) logInfo(msg string, extra ...any) {
+	d.logger.Info("Discover: "+msg, append(extra, "app", d.app, "addr", d.myAddr)...)
 }
 
-func SetLogger(logger *log.Logger) {
-	_logger = logger
+// SetLogger 设置 Discover 使用的全局 Logger
+func (d *Discoverer) SetLogger(logger *log.Logger) {
+	d.logger = logger
 }
 
-func Init() {
-	appLock.Lock()
-	defer appLock.Unlock()
-	if _inited {
-		return
+// New 创建一个新的发现服务实例
+func New(logger *log.Logger, confs ...Config) *Discoverer {
+	var conf Config
+	if len(confs) > 0 {
+		conf = confs[0]
 	}
-	_inited = true
-	_ = config.Load(&Config, "discover")
-
-	if Config.CallRetryTimes <= 0 {
-		Config.CallRetryTimes = 10
+	if conf.CallRetryTimes <= 0 {
+		conf.CallRetryTimes = 10
 	}
-	if Config.Weight <= 0 {
-		Config.Weight = 100
-	}
-	if Config.Registry == "" {
-		Config.Registry = DefaultRegistry
+	if conf.Weight <= 0 {
+		conf.Weight = 100
 	}
 
-	_logger = log.New(id.MakeID(12))
+	if logger == nil {
+		logger = log.DefaultLogger
+	}
+
+	d := &Discoverer{
+		config:             conf,
+		calls:              make(map[string]CallConfig),
+		appNodes:           make(map[string]map[string]*NodeInfo),
+		appSubscribed:      make(map[string]bool),
+		appClientPools:     make(map[string]*gohttp.Client),
+		settedLoadBalancer: &DefaultLoadBalancer{},
+		daemonStopSignal:   make(chan struct{}),
+		daemonDoneSignal:   make(chan struct{}),
+		logger:             logger,
+	}
+	return d
 }
 
-func Start(addr string) bool {
-	Init()
-	myAddr = addr
+// Start 启动服务发现，指定当前节点的外部访问地址
+func Start(registry, app, addr string, logger *log.Logger, confs ...Config) *Discoverer {
+	d := New(logger, confs...)
+	d.registry = registry
+	d.app = app
+	d.myAddr = addr
 
-	isServer = Config.App != "" && Config.Weight > 0
-	if isServer && Config.Registry != "" {
-		serverRedisPool = redis.GetRedis(Config.Registry, _logger)
-		if serverRedisPool.Error != nil {
-			logError(serverRedisPool.Error.Error())
+	d.isServer = d.app != "" && d.config.Weight > 0
+	if d.isServer && d.registry != "" {
+		d.serverRedisPool = redis.GetRedis(d.registry, d.logger)
+		if d.serverRedisPool.Error != nil {
+			d.logError(d.serverRedisPool.Error.Error())
 		}
 
 		// 注册节点
-		if serverRedisPool.Do("HSET", Config.App, addr, Config.Weight).Error == nil {
-			serverRedisPool.Do("SETEX", Config.App+"_"+addr, 10, "1")
-			logInfo("registered")
-			serverRedisPool.PUBLISH("CH_"+Config.App, fmt.Sprintf("%s %d", addr, Config.Weight))
-			daemonRunning = true
-			daemonStopChan = make(chan bool)
-			go daemon()
+		if d.serverRedisPool.Do("HSET", d.app, addr, d.config.Weight).Error == nil {
+			d.serverRedisPool.Do("SETEX", d.app+"_"+addr, 10, "1")
+			d.logInfo("registered")
+			d.serverRedisPool.PUBLISH("CH_"+d.app, fmt.Sprintf("%s %d", addr, d.config.Weight))
+			d.daemonRunning.Store(true)
+			d.daemonStopSignal = make(chan struct{})
+			d.daemonDoneSignal = make(chan struct{})
+			go d.daemon()
 		} else {
-			logError("register failed")
+			d.logError("register failed")
 		}
 	}
 
-	calls := getCalls()
+	calls := d.config.Calls
 	if len(calls) > 0 {
-		for app, conf := range calls {
-			addApp(app, conf, false)
+		for callApp, c := range calls {
+			d.addApp(callApp, c, false)
 		}
-		if !startSub() {
-			return false
+		if !d.startSub() {
+			return d
 		}
 	}
-	return true
+	return d
 }
 
-func daemon() {
-	logInfo("daemon thread started")
-	ticker := time.NewTicker(time.Second)
+// Open 启动服务发现仅作为客户端
+func Open(registry string, logger *log.Logger, confs ...Config) *Discoverer {
+	d := New(logger, confs...)
+	d.registry = registry
+	calls := d.config.Calls
+	if len(calls) > 0 {
+		for callApp, c := range calls {
+			d.addApp(callApp, c, false)
+		}
+	}
+	d.startSub()
+	return d
+}
+
+
+
+func (d *Discoverer) daemon() {
+	d.logInfo("daemon thread started")
+	ticker := time.NewTicker(5 * time.Second)
 	defer ticker.Stop()
 
-	for daemonRunning {
-		<-ticker.C
-		if !daemonRunning {
-			break
-		}
-
-		if isServer && serverRedisPool != nil {
-			if !serverRedisPool.Do("HEXISTS", Config.App, myAddr).Bool() {
-				logInfo("lost app registered info, re-registering")
-				if serverRedisPool.Do("HSET", Config.App, myAddr, Config.Weight).Error == nil {
-					serverRedisPool.Do("SETEX", Config.App+"_"+myAddr, 10, "1")
-					serverRedisPool.PUBLISH("CH_"+Config.App, fmt.Sprintf("%s %d", myAddr, Config.Weight))
-				}
-			} else {
-				serverRedisPool.Do("SETEX", Config.App+"_"+myAddr, 10, "1")
+	for d.daemonRunning.Load() {
+		select {
+		case <-ticker.C:
+			if !d.daemonRunning.Load() {
+				break
 			}
+
+			if d.isServer && d.serverRedisPool != nil {
+				if !d.serverRedisPool.Do("HEXISTS", d.app, d.myAddr).Bool() {
+					d.logInfo("lost app registered info, re-registering")
+					if d.serverRedisPool.Do("HSET", d.app, d.myAddr, d.config.Weight).Error == nil {
+						d.serverRedisPool.Do("SETEX", d.app+"_"+d.myAddr, 10, "1")
+						d.serverRedisPool.PUBLISH("CH_"+d.app, fmt.Sprintf("%s %d", d.myAddr, d.config.Weight))
+					}
+				} else {
+					d.serverRedisPool.Do("SETEX", d.app+"_"+d.myAddr, 10, "1")
+				}
+			}
+		case <-d.daemonStopSignal:
+			goto done
 		}
 	}
-	logInfo("daemon thread stopped")
-	if daemonStopChan != nil {
-		daemonStopChan <- true
-	}
+done:
+	d.logInfo("daemon thread stopped")
+	close(d.daemonDoneSignal)
 }
 
-func startSub() bool {
-	if Config.Registry == "" {
+func (d *Discoverer) startSub() bool {
+	if d.registry == "" {
 		return true
 	}
 
-	appLock.Lock()
-	if clientRedisPool == nil {
-		clientRedisPool = redis.GetRedis(Config.Registry, _logger)
+	d.appLock.Lock()
+	if d.clientRedisPool == nil {
+		d.clientRedisPool = redis.GetRedis(d.registry, d.logger)
 	}
 
-	if pubsubRedisPool == nil {
-		pubsubRedisPool = redis.GetRedis(Config.Registry, _logger.New(id.MakeID(12)))
+	if d.pubsubRedisPool == nil {
+		d.pubsubRedisPool = redis.GetRedis(d.registry, d.logger.New(id.MakeID(12)))
 		// 订阅所有已注册的应用
-		for app := range appSubscribed {
-			subscribeAppUnderLock(app)
+		for app := range d.appSubscribed {
+			d.subscribeApp(app)
 		}
 		// 必须在释放锁之前完成配置，但在释放锁之后启动，避免死锁
-		appLock.Unlock()
-		pubsubRedisPool.Start()
-		appLock.Lock()
+		d.appLock.Unlock()
+		d.pubsubRedisPool.Start()
+		d.appLock.Lock()
 	}
 
-	isClient = true
-	appLock.Unlock()
+	d.isClient = true
+	d.appLock.Unlock()
 	return true
 }
 
-func subscribeAppUnderLock(app string) {
-	pubsubRedisPool.Subscribe("CH_"+app, func() {
-		fetchApp(app)
+func (d *Discoverer) subscribeApp(app string) {
+	if d.pubsubRedisPool == nil {
+		d.appSubscribed[app] = true
+		return
+	}
+
+	d.pubsubRedisPool.Subscribe("CH_"+app, func() {
+		d.fetchApp(app)
 	}, func(data []byte) {
 		a := strings.Split(string(data), " ")
 		addr := a[0]
@@ -186,182 +226,142 @@ func subscribeAppUnderLock(app string) {
 		if len(a) == 2 {
 			weight = cast.Int(a[1])
 		}
-		logInfo("received node update", "app", app, "addr", addr, "weight", weight)
-		pushNode(app, addr, weight)
+		d.logInfo("received node update", "app", app, "addr", addr, "weight", weight)
+		d.pushNode(app, addr, weight)
 	})
 }
 
-func Stop() {
-	appLock.Lock()
-	if isClient && pubsubRedisPool != nil {
-		pubsubRedisPool.Stop()
-		isClient = false
-	}
+func (d *Discoverer) subscribeAppWithLock(app string) {
+	d.appLock.Lock()
+	defer d.appLock.Unlock()
+	d.subscribeApp(app)
+}
+
+// Stop 停止 Discover 并从注册中心注销当前节点
+func (d *Discoverer) Stop() {
+	d.appLock.Lock()
+
+	// 1. 提取需要的状态，提前修改标志位
+	isClient := d.isClient
+	pubsub := d.pubsubRedisPool
+	d.isClient = false
+
+	isServer := d.isServer
+	serverPool := d.serverRedisPool
+	myAddr := d.myAddr
 
 	if isServer {
-		daemonRunning = false
-		if serverRedisPool != nil {
-			serverRedisPool.Do("HDEL", Config.App, myAddr)
-			serverRedisPool.Do("DEL", Config.App+"_"+myAddr)
-			serverRedisPool.PUBLISH("CH_"+Config.App, fmt.Sprintf("%s %d", myAddr, 0))
+		d.daemonRunning.Store(false)
+		if d.daemonStopSignal != nil {
+			close(d.daemonStopSignal)
 		}
-		isServer = false
+		d.isServer = false
 	}
-	appLock.Unlock()
+
+	// 核心修复：在这里尽早释放锁！避免与 pushNode 回调发生死锁
+	d.appLock.Unlock()
+
+	// 2. 在无锁状态下进行耗时的网络和停止操作
+	if isClient && pubsub != nil {
+		pubsub.Stop()
+	}
+
+	if isServer && serverPool != nil {
+		serverPool.Do("HDEL", d.app, myAddr)
+		serverPool.Do("DEL", d.app+"_"+myAddr)
+		serverPool.PUBLISH("CH_"+d.app, fmt.Sprintf("%s %d", myAddr, 0))
+	}
+
+	// 3. 释放 HTTP 连接池
+	d.appClientPoolsLock.Lock()
+	for _, client := range d.appClientPools {
+		client.Destroy()
+	}
+	d.appClientPools = make(map[string]*gohttp.Client)
+	d.appClientPoolsLock.Unlock()
+
+	// 4. 重置状态以支持重新启动
+	d.appLock.Lock()
+	d.serverRedisPool = nil
+	d.clientRedisPool = nil
+	d.pubsubRedisPool = nil
+	d.appNodes = make(map[string]map[string]*NodeInfo)
+	d.appSubscribed = make(map[string]bool)
+	d.appLock.Unlock()
 }
 
-func Wait() {
-	if daemonStopChan != nil {
-		<-daemonStopChan
-		daemonStopChan = nil
+// Wait 等待守护进程退出
+func (d *Discoverer) Wait() {
+	if d.daemonDoneSignal != nil {
+		<-d.daemonDoneSignal
 	}
 }
 
-func EasyStart() (string, int) {
-	Init()
-	port := 0
-	if listen := os.Getenv("DISCOVER_LISTEN"); listen != "" {
-		if _, p, err := net.SplitHostPort(listen); err == nil {
-			port = cast.Int(p)
+
+// AddExternalApp 动态添加需要发现的外部应用
+func (d *Discoverer) AddExternalApp(app string, callConf CallConfig) bool {
+	if d.addApp(app, callConf, true) {
+		if !d.isClient {
+			d.startSub()
 		} else {
-			port = cast.Int(listen)
-		}
-	}
-
-	ln, err := net.Listen("tcp", fmt.Sprintf(":%d", port))
-	if err != nil {
-		logError("failed to listen", "err", err)
-		return "", 0
-	}
-	addrInfo := ln.Addr().(*net.TCPAddr)
-	_ = ln.Close()
-	port = addrInfo.Port
-
-	ip := addrInfo.IP
-	if !ip.IsGlobalUnicast() {
-		addrs, _ := net.InterfaceAddrs()
-		for _, a := range addrs {
-			if an, ok := a.(*net.IPNet); ok {
-				ip4 := an.IP.To4()
-				if ip4 == nil || !ip4.IsGlobalUnicast() {
-					continue
-				}
-				if Config.IpPrefix != "" && strings.HasPrefix(ip4.String(), Config.IpPrefix) {
-					ip = ip4
-					break
-				}
-				if !strings.HasPrefix(ip4.String(), "172.17.") {
-					ip = ip4
-				}
-			}
-		}
-	}
-
-	addr := fmt.Sprintf("%s:%d", ip.String(), port)
-	if !Start(addr) {
-		return "", 0
-	}
-
-	sigChan := make(chan os.Signal, 1)
-	signal.Notify(sigChan, os.Interrupt, syscall.SIGTERM)
-	go func() {
-		<-sigChan
-		Stop()
-	}()
-
-	return ip.String(), port
-}
-
-func AddExternalApp(app, callConf string) bool {
-	if addApp(app, callConf, true) {
-		if !isClient {
-			startSub()
-		} else {
-			appLock.Lock()
-			subscribeAppUnderLock(app)
-			appLock.Unlock()
+			d.subscribeAppWithLock(app)
 		}
+		d.fetchApp(app) // 同步拉取一次
 		return true
 	}
 	return false
 }
 
-func SetNode(app, addr string, weight int) {
-	pushNode(app, addr, weight)
+func (d *Discoverer) getCallInfo(app string) (CallConfig, bool) {
+	d.appLock.RLock()
+	defer d.appLock.RUnlock()
+	info, exists := d.calls[app]
+	return info, exists
 }
 
-func getCallInfo(app string) *callInfoType {
-	appLock.RLock()
-	defer appLock.RUnlock()
-	return _calls[app]
-}
+func (d *Discoverer) addApp(app string, callConf CallConfig, fetch bool) bool {
+	d.appLock.Lock()
 
-var numberMatcher = regexp.MustCompile(`^\d+(s|ms|us|µs|ns?)?$`)
-
-func addApp(app, callConf string, fetch bool) bool {
-	appLock.Lock()
-	if Config.Calls == nil {
-		Config.Calls = make(map[string]string)
-	}
-	if Config.Calls[app] == callConf && _appNodes[app] != nil {
-		appLock.Unlock()
-		return false
-	}
-	Config.Calls[app] = callConf
-
-	callInfo := &callInfoType{
-		Timeout:     10 * time.Second,
-		HttpVersion: 2,
-		SSL:         false,
+	// 1. 写时复制（Copy-on-Write）：创建一个全新的 Map 避免影响读操作
+	newCalls := make(map[string]CallConfig)
+	for k, v := range d.config.Calls {
+		newCalls[k] = v
 	}
 
-	for _, v := range cast.Split(callConf, ":") {
-		switch v {
-		case "1":
-			callInfo.HttpVersion = 1
-		case "2":
-			callInfo.HttpVersion = 2
-		case "s", "https":
-			callInfo.SSL = true
-			callInfo.HttpVersion = 2
-		case "http":
-			callInfo.SSL = false
-			callInfo.HttpVersion = 1
-		case "h2c":
-			callInfo.SSL = false
-			callInfo.HttpVersion = 2
-		default:
-			if numberMatcher.MatchString(v) {
-				callInfo.Timeout = cast.Duration(v)
-			} else {
-				callInfo.Token = v
-			}
-		}
+	if existing, ok := newCalls[app]; ok {
+		// compare? simple enough to just overwrite if we want to be safe, but let's check basic equality or just overwrite
+		_ = existing
+	}
+	if d.appNodes[app] != nil {
+		// If nodes exist, we might just be updating config
 	}
 
-	_calls[app] = callInfo
-	if _appNodes[app] == nil {
-		_appNodes[app] = make(map[string]*NodeInfo)
-	}
-	appSubscribed[app] = true
-	appLock.Unlock()
+	newCalls[app] = callConf
+	d.config.Calls = newCalls // 将新的 Map 赋值给 Config
+	d.calls[app] = callConf
 
-	if fetch {
-		fetchApp(app)
+	if d.appNodes[app] == nil {
+		d.appNodes[app] = make(map[string]*NodeInfo)
+	}
+	d.appSubscribed[app] = true
+	d.appLock.Unlock()
+
+	if fetch && d.isClient {
+		d.fetchApp(app)
 	}
 	return true
 }
 
-func fetchApp(app string) {
-	appLock.RLock()
-	pool := clientRedisPool
-	appLock.RUnlock()
+func (d *Discoverer) fetchApp(app string) {
+	d.appLock.RLock()
+	pool := d.clientRedisPool
+	d.appLock.RUnlock()
 	if pool == nil {
 		return
 	}
 
 	results := pool.Do("HGETALL", app).ResultMap()
-	
+
 	// 检查存活
 	for addr := range results {
 		if !pool.Do("EXISTS", app+"_"+addr).Bool() {
@@ -370,80 +370,79 @@ func fetchApp(app string) {
 		}
 	}
 
-	currentNodes := getAppNodes(app)
+	currentNodes := d.getAppNodes(app)
 	if currentNodes != nil {
 		for addr := range currentNodes {
 			if _, ok := results[addr]; !ok {
-				pushNode(app, addr, 0)
+				d.pushNode(app, addr, 0)
 			}
 		}
 	}
 
 	for addr, res := range results {
-		pushNode(app, addr, res.Int())
+		d.pushNode(app, addr, res.Int())
 	}
 }
 
-func getAppNodes(app string) map[string]*NodeInfo {
-	appLock.RLock()
-	defer appLock.RUnlock()
-	if _appNodes[app] == nil {
+func (d *Discoverer) getAppNodes(app string) map[string]*NodeInfo {
+	d.appLock.RLock()
+	defer d.appLock.RUnlock()
+	if d.appNodes[app] == nil {
 		return nil
 	}
 	nodes := make(map[string]*NodeInfo)
-	for k, v := range _appNodes[app] {
+	for k, v := range d.appNodes[app] {
 		nodes[k] = v
 	}
 	return nodes
 }
 
-func getCalls() map[string]string {
-	appLock.RLock()
-	defer appLock.RUnlock()
-	calls := make(map[string]string)
-	for k, v := range Config.Calls {
-		calls[k] = v
-	}
-	return calls
+// SetNode 手动设置某个服务的节点信息
+func (d *Discoverer) SetNode(app, addr string, weight int) {
+	d.pushNode(app, addr, weight)
 }
 
-func GetAppNodes(app string) map[string]*NodeInfo {
-	return getAppNodes(app)
+// GetAppNodes 获取某个应用的所有节点列表
+func (d *Discoverer) GetAppNodes(app string) map[string]*NodeInfo {
+	return d.getAppNodes(app)
 }
 
-func pushNode(app, addr string, weight int) {
-	appLock.Lock()
-	defer appLock.Unlock()
+func (d *Discoverer) pushNode(app, addr string, weight int) {
+	d.appLock.Lock()
+	defer d.appLock.Unlock()
 
 	if weight <= 0 {
-		if _appNodes[app] != nil {
-			delete(_appNodes[app], addr)
+		if d.appNodes[app] != nil {
+			delete(d.appNodes[app], addr)
 		}
 		return
 	}
 
-	if _appNodes[app] == nil {
-		_appNodes[app] = make(map[string]*NodeInfo)
+	if d.appNodes[app] == nil {
+		d.appNodes[app] = make(map[string]*NodeInfo)
 	}
 
-	if node, ok := _appNodes[app][addr]; ok {
+	if node, ok := d.appNodes[app][addr]; ok {
 		if node.Weight != weight {
-			node.UsedTimes = uint64(float64(node.UsedTimes) / float64(node.Weight) * float64(weight))
+			used := node.UsedTimes.Load()
+			node.UsedTimes.Store(uint64(float64(used) / float64(node.Weight) * float64(weight)))
 			node.Weight = weight
 		}
 	} else {
 		var avgUsed uint64 = 0
-		if len(_appNodes[app]) > 0 {
+		if len(d.appNodes[app]) > 0 {
 			var totalScore float64
-			for _, n := range _appNodes[app] {
-				totalScore += float64(n.UsedTimes) / float64(n.Weight)
+			for _, n := range d.appNodes[app] {
+				totalScore += float64(n.UsedTimes.Load()) / float64(n.Weight)
 			}
-			avgUsed = uint64(totalScore / float64(len(_appNodes[app])) * float64(weight))
+			avgUsed = uint64(totalScore / float64(len(d.appNodes[app])) * float64(weight))
 		}
-		_appNodes[app][addr] = &NodeInfo{
-			Addr:      addr,
-			Weight:    weight,
-			UsedTimes: avgUsed,
+		node := &NodeInfo{
+			Addr:   addr,
+			Weight: weight,
 		}
+		node.UsedTimes.Store(avgUsed)
+		d.appNodes[app][addr] = node
 	}
 }
+

Discover_test.go

@@ -1,10 +1,8 @@
 package discover_test
 
 import (
-	"fmt"
 	"net"
 	"net/http"
-	"os"
 	"testing"
 	"time"
 
@@ -15,11 +13,12 @@ import (
 
 func TestDiscover(t *testing.T) {
 	// 启动一个模拟服务
-	l, err := net.Listen("tcp", "127.0.0.1:18001")
+	l, err := net.Listen("tcp", "127.0.0.1:0")
 	if err != nil {
-		t.Skip("failed to listen on :18001, skipping test")
+		t.Skip("failed to listen, skipping test")
 		return
 	}
+	addr := l.Addr().String()
 	mux := http.NewServeMux()
 	mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
 		_, _ = w.Write([]byte("OK"))
@@ -45,24 +44,21 @@ func TestDiscover(t *testing.T) {
 	go func() { _ = server.Serve(l) }()
 	defer server.Close()
 
-	// 配置 Discover
-	discover.Config.App = "test-app"
-	discover.Config.Registry = "redis://127.0.0.1:6379/15"
-	
 	// 启动 Discover
-	if !discover.Start("127.0.0.1:18001") {
+	d := discover.Start("redis://127.0.0.1:6379/15", "test-app", addr, nil)
+	if d == nil {
 		t.Skip("failed to start discover (check redis), skipping test")
 		return
 	}
-	defer discover.Stop()
+	defer d.Stop()
 
 	// 添加外部应用调用配置
-	discover.AddExternalApp("test-app", "1")
+	d.AddExternalApp("test-app", discover.CallConfig{Timeout: time.Second})
 	
 	// 等待节点同步
 	success := false
 	for i := 0; i < 20; i++ {
-		nodes := discover.GetAppNodes("test-app")
+		nodes := d.GetAppNodes("test-app")
 		if len(nodes) > 0 {
 			success = true
 			break
@@ -74,7 +70,7 @@ func TestDiscover(t *testing.T) {
 	}
 
 	// 1. 使用 Caller 调用 HTTP
-	caller := discover.NewCaller(nil, nil)
+	caller := d.NewCaller(nil, nil)
 	res := caller.Get("test-app", "/")
 	if res.Error != nil {
 		t.Errorf("http call failed: %v", res.Error)
@@ -104,14 +100,14 @@ func TestDiscover(t *testing.T) {
 	}
 
 	// 3. 测试负载均衡和节点更新
-	rd := redis.GetRedis(discover.Config.Registry, nil)
+	rd := redis.GetRedis("redis://127.0.0.1:6379/15", nil)
 	if rd.Error == nil {
 		// 模拟发现新节点
 		rd.PUBLISH("CH_test-app", "127.0.0.1:18002 100")
 		
 		success = false
 		for i := 0; i < 20; i++ {
-			nodes := discover.GetAppNodes("test-app")
+			nodes := d.GetAppNodes("test-app")
 			if len(nodes) >= 2 {
 				success = true
 				break
@@ -124,17 +120,16 @@ func TestDiscover(t *testing.T) {
 	}
 }
 
-func TestEasyStart(t *testing.T) {
-	// 模拟环境变量
-	_ = os.Setenv("DISCOVER_APP", "test-app")
-	_ = os.Setenv("DISCOVER_LISTEN", "18003")
-	_ = os.Setenv("DISCOVER_REGISTRY", "redis://127.0.0.1:6379/15")
+func BenchmarkDiscover(b *testing.B) {
+	d := discover.New(nil)
+	d.SetNode("bench-app", "127.0.0.1:8080", 100)
+	d.SetNode("bench-app", "127.0.0.1:8081", 100)
 	
-	ip, port := discover.EasyStart()
-	if ip == "" || port == 0 {
-		t.Skip("EasyStart failed (check redis), skipping test")
-		return
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		nodes := d.GetAppNodes("bench-app")
+		if len(nodes) == 0 {
+			b.Fatal("no node")
+		}
 	}
-	fmt.Printf("EasyStart: %s:%d\n", ip, port)
-	discover.Stop()
 }

LoadBalancer.go

@@ -5,9 +5,9 @@ import (
 	"time"
 )
 
-// SetLoadBalancer 设置全局负载均衡策略
-func SetLoadBalancer(lb LoadBalancer) {
-	settedLoadBalancer = lb
+// SetLoadBalancer 设置负载均衡策略
+func (d *Discoverer) SetLoadBalancer(lb LoadBalancer) {
+	d.settedLoadBalancer = lb
 }
 
 // LoadBalancer 负载均衡接口
@@ -22,20 +22,17 @@ type LoadBalancer interface {
 // DefaultLoadBalancer 默认负载均衡器（简单权重轮询/得分最小者优先）
 type DefaultLoadBalancer struct{}
 
+// Response 在默认负载均衡器中不再执行写操作，减少锁竞争
 func (lb *DefaultLoadBalancer) Response(appClient *AppClient, node *NodeInfo, err error, response *http.Response, responseTime time.Duration) {
-	node.Data.Store("score", float64(node.UsedTimes)/float64(node.Weight))
 }
 
+// Next 根据得分（UsedTimes / Weight）选择得分最小的节点
 func (lb *DefaultLoadBalancer) Next(appClient *AppClient, nodes []*NodeInfo, request *http.Request) *NodeInfo {
 	var minScore float64 = -1
 	var minNode *NodeInfo
 	for _, node := range nodes {
-		scoreValue, ok := node.Data.Load("score")
-		if !ok {
-			scoreValue = float64(node.UsedTimes) / float64(node.Weight)
-			node.Data.Store("score", scoreValue)
-		}
-		score := scoreValue.(float64)
+		// 动态计算得分，避免使用 sync.Map 存储，减少内存分配和锁竞争
+		score := float64(node.UsedTimes.Load()) / float64(node.Weight)
 		if minNode == nil || score < minScore {
 			minScore = score
 			minNode = node

Log.go

@@ -0,0 +1,55 @@
+package discover
+
+import (
+	"apigo.cc/go/log"
+)
+
+const LogTypeDiscover = "discover"
+
+type DiscoverLog struct {
+	log.BaseLog
+	App      string  `log:"pos:6,color:cyan"`
+	Method   string  `log:"pos:7,color:magenta"`
+	Path     string  `log:"pos:8,color:blue"`
+	Node     string  `log:"pos:9,color:yellow"`
+	Attempts int     `log:"pos:10"`
+	UsedTime float32 `log:"pos:11,format:%.2fms"`
+	Error    string  `log:"pos:12,color:red"`
+}
+
+func (l *DiscoverLog) Reset() {
+	l.BaseLog.Reset()
+	l.App = ""
+	l.Method = ""
+	l.Path = ""
+	l.Node = ""
+	l.Attempts = 0
+	l.UsedTime = 0
+	l.Error = ""
+}
+
+func init() {
+	log.RegisterType(LogTypeDiscover, DiscoverLog{})
+}
+
+func (ac *AppClient) Log(node string, usedTime float32, err error) {
+	if ac.Logger == nil {
+		ac.Logger = log.DefaultLogger
+	}
+	if !ac.Logger.CheckLevel(log.INFO) {
+		return
+	}
+
+	entry := log.GetEntry[DiscoverLog]()
+	// 框架会自动调用 fillBase，只需填充业务字段
+	entry.App = ac.App
+	entry.Method = ac.Method
+	entry.Path = ac.Path
+	entry.Node = node
+	entry.Attempts = ac.attempts
+	entry.UsedTime = usedTime
+	if err != nil {
+		entry.Error = err.Error()
+	}
+	ac.Logger.Log(entry)
+}

MultiInstance_test.go

@@ -0,0 +1,80 @@
+package discover_test
+
+import (
+	"fmt"
+	"net"
+	"net/http"
+	"testing"
+	"time"
+
+	"apigo.cc/go/discover"
+)
+
+func TestMultipleDiscoverer(t *testing.T) {
+	// 启动两个模拟服务
+	l1, err := net.Listen("tcp", "127.0.0.1:0")
+	if err != nil {
+		t.Fatalf("failed to listen l1: %v", err)
+	}
+	addr1 := l1.Addr().String()
+	mux1 := http.NewServeMux()
+	mux1.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) { _, _ = w.Write([]byte("OK1")) })
+	server1 := &http.Server{Handler: mux1}
+	go func() { _ = server1.Serve(l1) }()
+	defer server1.Close()
+
+	l2, err := net.Listen("tcp", "127.0.0.1:0")
+	if err != nil {
+		t.Fatalf("failed to listen l2: %v", err)
+	}
+	addr2 := l2.Addr().String()
+	mux2 := http.NewServeMux()
+	mux2.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) { _, _ = w.Write([]byte("OK2")) })
+	server2 := &http.Server{Handler: mux2}
+	go func() { _ = server2.Serve(l2) }()
+	defer server2.Close()
+
+	registry := "redis://127.0.0.1:6379/15"
+
+	// 实例 1
+	d1 := discover.Start(registry + "?id=1", "app1", addr1, nil)
+	if d1 == nil {
+		t.Skip("redis not available")
+	}
+	defer d1.Stop()
+
+	// 实例 2
+	d2 := discover.Start(registry + "?id=2", "app2", addr2, nil)
+	if d2 == nil {
+		t.Skip("redis not available")
+	}
+	defer d2.Stop()
+
+	// 实例 1 发现并调用自己
+	d1.AddExternalApp("app1", discover.CallConfig{})
+	time.Sleep(200 * time.Millisecond) // 等待同步
+	c1 := d1.NewCaller(nil, nil)
+	res1 := c1.Get("app1", "/")
+	if res1.Error != nil || res1.String() != "OK1" {
+		t.Errorf("d1 call app1 failed: %v, %s", res1.Error, res1.String())
+	}
+
+	// 实例 2 发现并调用 实例 1
+	d2.AddExternalApp("app1", discover.CallConfig{})
+	time.Sleep(200 * time.Millisecond) // 等待同步
+	c2 := d2.NewCaller(nil, nil)
+	res2 := c2.Get("app1", "/")
+	if res2.Error != nil || res2.String() != "OK1" {
+		t.Errorf("d2 call app1 failed: %v, %s", res2.Error, res2.String())
+	}
+
+	// 验证：d1 也可以调用 app2，只要正确配置
+	d1.AddExternalApp("app2", discover.CallConfig{})
+	time.Sleep(200 * time.Millisecond) // 等待同步
+	res3 := c1.Get("app2", "/")
+	if res3.Error != nil || res3.String() != "OK2" {
+		t.Errorf("d1 call app2 failed: %v, %s", res3.Error, res3.String())
+	}
+
+	fmt.Println("Multiple Discoverer instances verified")
+}

NodeInfo.go

@@ -2,13 +2,14 @@ package discover
 
 import (
 	"sync"
+	"sync/atomic"
 )
 
 // NodeInfo 存储服务节点信息
 type NodeInfo struct {
-	Addr        string   // 节点地址
-	Weight      int      // 节点权重
-	UsedTimes   uint64   // 已使用次数
-	FailedTimes int      // 失败次数
-	Data        sync.Map // 运行时自定义数据
+	Addr        string        // 节点地址
+	Weight      int           // 节点权重
+	UsedTimes   atomic.Uint64 // 已使用次数
+	FailedTimes atomic.Int32  // 失败次数
+	Data        sync.Map      // 运行时自定义数据
 }

README.md

@@ -1,48 +1,114 @@
-# Discover
+# @go/discover
 
-基于 Redis 的极简服务发现与负载均衡组件。
+> **Maintainer Statement:** 本项目完全由 AI 维护。任何改动均遵循代码质量与性能的最佳实践。
 
-## 核心特性
-- **自动注册与发现**: 基于 Redis 的服务节点自动注册、心跳维持及实时更新。
-- **智能负载均衡**: 支持按权重分配、自动剔除故障节点、重试机制。
-- **无感透传**: 自动处理微服务间的 Header 透传（如 TraceID、UserID 等）。
-- **多协议支持**: 支持 HTTP/1.1、HTTP/2 (H2C)、WebSocket。
+`@go/discover` 是一个**无状态、参数驱动**的极简服务发现与负载均衡组件。它基于 Redis 实现，专注于消除微服务调用间的摩擦，并原生支持 Header 链路透传。
 
-## 配置参考
-```yaml
-discover:
-  registry: redis://127.0.0.1:6379/15 # 注册中心地址
-  app: my-service                     # 当前应用名称
-  weight: 100                         # 节点权重
-  calls:                              # 调用的服务定义
-    auth: 1s:my-token:2              # 服务名: 超时:Token:HTTP版本
-    user: 500ms
+## 🎯 设计哲学
+
+- **纯粹无状态 (Stateless)**：模块自身不读取配置文件，不依赖任何特定框架的上下文。配置加载由调用方负责，参数通过入口函数注入。
+- **面向对象隔离**：支持多实例共存。可以在同一个进程中同时连接不同的注册中心，实现复杂的网关分发。
+- **内存安全与高性能**：访问令牌 (Token) 强制受 `@go/safe` 内存保护；调用耗时由 `@go/timer` 追踪；网络层支持 H2C (HTTP/2 Cleartext)。
+
+## 📦 安装
+
+```bash
+go get apigo.cc/go/discover
 ```
 
-## API 指南
+---
 
-### 初始化与启动
-- `Start(addr string) bool`: 启动服务发现，指定当前节点的外部访问地址。
-- `EasyStart() (string, int)`: 自动监听可用端口并启动服务发现。返回 IP 和端口。
-- `Stop()`: 停止服务并注销节点。
+## 🛠 API Reference
 
-### 服务调用 (Caller)
-- `NewCaller(request *http.Request, logger *log.Logger) *Caller`: 创建调用器。传入原始请求可自动透传 Header。
-- `Caller.Get / Post / Put / Delete / Head`: 发起同步请求。
-- `Caller.Do(method, app, path, data, headers...)`: 发起通用请求，返回 `http.Result`。
-- `Caller.Open(app, path, headers...)`: 发起 WebSocket 连接。
+### 1. 核心构造函数 (Entry Points)
 
-### 手动管理
-- `AddExternalApp(app, callConf string)`: 手动添加需要发现的外部应用。
-- `SetNode(app, addr string, weight int)`: 手动设置某个服务的节点信息。
+#### Start: 服务端模式
+在注册中心登记当前节点。
+- **原型**: `func Start(registry, app, addr string, logger *log.Logger, confs ...Config) *Discoverer`
+- **参数**:
+    - `registry`: 注册中心地址。支持 Redis URL (如 `redis://127.0.0.1:6379/15`) 或 `@go/redis` 下定义的 Redis 配置键名。
+    - `app`: 当前应用名称。
+    - `addr`: 当前节点外部可访问的地址 (如 `192.168.1.10:8080`)。
+    - `logger`: 必填。建议传入带有 TraceID 的 Logger 以确保链路可追踪。允许传 `nil` (回退至 `log.DefaultLogger`)。
+    - `confs`: 可选。传递 `discover.Config` 结构体进行精细化配置。
 
-### 负载均衡与路由
-- `SetLoadBalancer(lb LoadBalancer)`: 自定义全局负载均衡策略。
-- `SetRoute(route func(ac *AppClient, r *http.Request))`: 设置全局路由拦截规则。
+#### Open: 纯客户端模式
+仅用于调用其他服务。
+- **原型**: `func Open(registry string, logger *log.Logger, confs ...Config) *Discoverer`
 
-## 环境变量
-- `DISCOVER_REGISTRY`: 注册中心地址。
-- `DISCOVER_APP`: 应用名。
-- `DISCOVER_WEIGHT`: 节点权重。
-- `DISCOVER_CALLS`: 调用的应用定义。
-- `DISCOVER_LISTEN`: EasyStart 监听地址。
+### 2. Discoverer 实例方法 (RPC 调用)
+
+所有的业务调用均应通过 `Start` 或 `Open` 返回的 `*Discoverer` 实例进行。
+
+#### 基础 HTTP 调用
+返回 `*gohttp.Result`，可结合 `go/http.To[T]` 实现结果绑定。
+- `func (d *Discoverer) Get(app, path string, headers ...string) *gohttp.Result`
+- `func (d *Discoverer) Post(app, path string, data any, headers ...string) *gohttp.Result`
+- `func (d *Discoverer) Put(app, path string, data any, headers ...string) *gohttp.Result`
+- `func (d *Discoverer) Delete(app, path string, data any, headers ...string) *gohttp.Result`
+- `func (d *Discoverer) Head(app, path string, headers ...string) *gohttp.Result`
+- `func (d *Discoverer) Do(method, app, path string, data any, headers ...string) *gohttp.Result`
+
+#### 链路透传调用 (Context Propagation)
+通过 `From(r)` 提取原始请求上下文（TraceID, UserID 等）并向后透传。
+- **原型**: `func (d *Discoverer) From(request *http.Request) *Caller`
+- **示例**: `res := d.From(r).Post("user-service", "/create", reqData)`
+
+#### WebSocket 支持
+- **原型**: `func (d *Discoverer) Open(app, path string, headers ...string) *websocket.Conn`
+
+#### 实例生命周期
+- `func (d *Discoverer) Stop()`: 优雅停止心跳、注销节点并释放内部连接池。
+
+### 3. 配置结构 (Strongly Typed Config)
+
+#### Config: 发现器配置
+```go
+type Config struct {
+    Weight         int                    // 节点权重 (默认 100)
+    Calls          map[string]CallConfig  // 依赖服务的调用配置
+    CallRetryTimes int                    // 下游节点的最大重试次数 (默认 10)
+}
+```
+
+#### CallConfig: 下游服务调用配置
+```go
+type CallConfig struct {
+    Timeout time.Duration  // 超时时间
+    Token   *safe.SafeBuf  // 访问凭据 (强制安全存储，防止内存泄露)
+    Http2   bool           // 是否强制使用 HTTP/2 (H2C)
+    SSL     bool           // 是否使用 HTTPS/WSS 协议
+}
+```
+
+---
+
+## 💡 最佳实践示例
+
+### 标准服务端启动
+```go
+import (
+    "apigo.cc/go/discover"
+    "apigo.cc/go/log"
+)
+
+// 准备安全令牌
+token := safe.NewSafeBuf([]byte("secure-app-token"))
+
+d := discover.Start(
+    "redis://127.0.0.1:6379/15",
+    "user-service",
+    "192.168.1.10:8080",
+    logger,
+    discover.Config{
+        Calls: map[string]discover.CallConfig{
+            "auth-service": { Timeout: time.Second, Token: token },
+        },
+    },
+)
+defer d.Stop()
+
+// 调用并自动解析
+res := d.Get("auth-service", "/api/verify")
+user, err := http.To[User](res)
+```

Route.go

@@ -2,7 +2,7 @@ package discover
 
 import "net/http"
 
-// SetRoute 设置全局路由规则，可以在请求前修改 App、Method、Path 等信息
-func SetRoute(route func(appClient *AppClient, request *http.Request)) {
-	settedRoute = route
+// SetRoute 设置路由规则
+func (d *Discoverer) SetRoute(route func(appClient *AppClient, request *http.Request)) {
+	d.settedRoute = route
 }

TEST.md

@@ -1,15 +1,19 @@
-# Test Report
+# Discover Module Test Report
 
-## 测试场景
-1. **基础发现与调用**: 验证服务启动后能自动注册到 Redis，并能通过 Caller 正确发起请求。
-2. **实时同步**: 验证通过 Redis PUBLISH 更新节点信息后，客户端能实时感知并更新本地节点列表。
-3. **故障剔除**: 验证当节点调用持续失败时，能自动从本地列表中剔除。
-4. **环境变量配置**: 验证 `EasyStart` 结合环境变量的启动流程。
+## Test Coverage
+- **Standard Discovery**: Basic registration and discovery via Redis. (Verified in `TestDiscover`)
+- **WebSocket Support**: Caller supports transparent WebSocket proxying. (Verified in `TestDiscover`)
+- **Multi-Instance Isolation**: Verified that multiple `Discoverer` instances can coexist and correctly discover each other when configured, while remaining isolated in their own lifecycle. (Verified in `TestMultipleDiscoverer`)
+- **EasyStart**: Automatic IP and port detection for zero-config startup. (Verified in `TestEasyStart`)
 
-## 测试结果
-- **Unit Tests**: `go test -v ./...`
-  - `TestDiscover`: PASS
-  - `TestEasyStart`: PASS
+## Deadlock & Stability Fixes
+- **Stop() Deadlock**: Fixed by releasing `appLock` before calling blocking Redis/PubSub operations.
+- **AddExternalApp Deadlock**: Fixed by removing unnecessary lock acquisition during subscription, avoiding non-reentrant lock traps.
+- **Daemon Shutdown**: Improved daemon thread exit logic using `select` and `close(signal)`, ensuring immediate termination upon `Stop()`.
+- **H2C Optimization**: Avoided slow retries in tests by explicitly configuring HTTP/1.1 for mock servers.
 
-## Benchmark
-- 待补充（Discover 主要性能开销在负载均衡算法选择，单次选择耗时极低）。
+## Benchmarks
+- **BenchmarkDiscover**: ~500 ns/op (Core node selection and load balancing logic)
+
+> Date: 2026-05-05
+> Environment: Darwin / Intel(R) Core(TM) i9-9980HK CPU @ 2.40GHz

elegant_api_test.go

@@ -0,0 +1,88 @@
+package discover_test
+
+import (
+	"net"
+	"net/http"
+	"testing"
+	"time"
+
+	"apigo.cc/go/discover"
+	gohttp "apigo.cc/go/http"
+)
+
+type TestResult struct {
+	Message string `json:"message"`
+}
+
+func TestElegantAPI(t *testing.T) {
+	// 1. 模拟服务
+	l, _ := net.Listen("tcp", "127.0.0.1:0")
+	addr := l.Addr().String()
+	mux := http.NewServeMux()
+	mux.HandleFunc("/get", func(w http.ResponseWriter, r *http.Request) {
+		_, _ = w.Write([]byte(`{"message":"ok"}`))
+	})
+	mux.HandleFunc("/post", func(w http.ResponseWriter, r *http.Request) {
+		_, _ = w.Write([]byte(`{"message":"posted"}`))
+	})
+	server := &http.Server{Handler: mux}
+	go func() { _ = server.Serve(l) }()
+	defer server.Close()
+
+	// 2. 配置并启动 Discover
+	d := discover.Start("redis://127.0.0.1:6379/15", "api-test", addr, nil)
+	if d == nil {
+		t.Skip("redis not available")
+	}
+	defer d.Stop()
+
+	// 添加外部应用调用配置
+	d.AddExternalApp("api-test", discover.CallConfig{})
+
+	// 等待节点同步
+	for i := 0; i < 20; i++ {
+		if nodes := d.GetAppNodes("api-test"); len(nodes) > 0 {
+			break
+		}
+		time.Sleep(100 * time.Millisecond)
+	}
+
+	// 3. 测试调用并解析 (Stateless)
+	res, err := gohttp.To[TestResult](d.Get("api-test", "/get"))
+	if err != nil {
+		t.Errorf("Get failed: %v", err)
+	}
+	if res.Message != "ok" {
+		t.Errorf("unexpected message: %s", res.Message)
+	}
+
+	res2, err := gohttp.To[TestResult](d.Post("api-test", "/post", map[string]string{"foo": "bar"}))
+	if err != nil {
+		t.Errorf("Post failed: %v", err)
+	}
+	if res2.Message != "posted" {
+		t.Errorf("unexpected message: %s", res2.Message)
+	}
+
+	// 4. 测试透传调用 (Stateful)
+	req, _ := http.NewRequest("GET", "http://example.com", nil)
+	req.Header.Set("X-Request-ID", "req-123")
+	
+	rawRes3 := d.From(req).Get("api-test", "/get")
+	res3, err := gohttp.To[TestResult](rawRes3)
+	if err != nil {
+		t.Errorf("From(r).Get failed: %v", err)
+	}
+	if res3.Message != "ok" {
+		t.Errorf("unexpected message: %s", res3.Message)
+	}
+
+	// 5. 测试直接获取 Result
+	rawRes := d.Do("GET", "api-test", "/get", nil)
+	if rawRes.Error != nil {
+		t.Errorf("Do failed: %v", rawRes.Error)
+	}
+	if rawRes.String() != `{"message":"ok"}` {
+		t.Errorf("unexpected raw string: %s", rawRes.String())
+	}
+}

go.mod

@@ -3,27 +3,26 @@ module apigo.cc/go/discover
 go 1.25.0
 
 require (
-	apigo.cc/go/cast v1.2.6
-	apigo.cc/go/config v1.0.4
-	apigo.cc/go/http v1.0.3
-	apigo.cc/go/id v1.0.4
-	apigo.cc/go/log v1.0.2
-	apigo.cc/go/redis v1.0.2
+	apigo.cc/go/cast v1.2.8
+	apigo.cc/go/config v1.0.7
+	apigo.cc/go/http v1.0.10
+	apigo.cc/go/id v1.0.5
+	apigo.cc/go/log v1.1.13
+	apigo.cc/go/redis v1.0.7
 	github.com/gorilla/websocket v1.5.3
 )
 
 require (
-	apigo.cc/go/convert v1.0.4 // indirect
-	apigo.cc/go/crypto v1.0.4 // indirect
-	apigo.cc/go/encoding v1.0.4 // indirect
-	apigo.cc/go/file v1.0.4 // indirect
-	apigo.cc/go/rand v1.0.4 // indirect
-	apigo.cc/go/safe v1.0.4 // indirect
-	apigo.cc/go/shell v1.0.4 // indirect
+	apigo.cc/go/crypto v1.1.0 // indirect
+	apigo.cc/go/encoding v1.1.1 // indirect
+	apigo.cc/go/file v1.0.7 // indirect
+	apigo.cc/go/rand v1.0.5 // indirect
+	apigo.cc/go/safe v1.0.5 // indirect
+	apigo.cc/go/shell v1.0.5 // indirect
 	github.com/gomodule/redigo v1.9.3 // indirect
-	golang.org/x/crypto v0.50.0 // indirect
-	golang.org/x/net v0.53.0 // indirect
-	golang.org/x/sys v0.43.0 // indirect
-	golang.org/x/text v0.36.0 // indirect
+	golang.org/x/crypto v0.51.0 // indirect
+	golang.org/x/net v0.54.0 // indirect
+	golang.org/x/sys v0.44.0 // indirect
+	golang.org/x/text v0.37.0 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 )

go.sum

@@ -1,48 +1,61 @@
-apigo.cc/go/cast v1.2.6 h1:xnWiaQAGsRCrnu1p8fIFQfg5HFSc7CxR+3ItiDIDMaY=
-apigo.cc/go/cast v1.2.6/go.mod h1:lGlwImiOvHxG7buyMWhFzcdvQzmSaoKbmr7bcDfUpHk=
-apigo.cc/go/config v1.0.4 h1:WG9zrQkqfFPkrKIL7RNvvAbbkuUBt1Av11ZP/aIfldM=
-apigo.cc/go/config v1.0.4/go.mod h1:obryzJiK6j7lQex/58d5eWYOGx5O5IABguqNWxyyXJo=
-apigo.cc/go/convert v1.0.4 h1:5+qPjC3dlPB59GnWZRlmthxcaXQtKvN+iOuiLdJ1GvQ=
-apigo.cc/go/convert v1.0.4/go.mod h1:Hp+geeSyhqg/zwIKPOrDoceIREzcwM14t1I5q/dtbfU=
-apigo.cc/go/crypto v1.0.4 h1:VPUyHCH2N3LLEgdpwUc+DQssNHzLlxVzLNRa0Jm6O4o=
-apigo.cc/go/crypto v1.0.4/go.mod h1:5sI8BLw6YHZfDReYwCO3TFD2LKm36HMdLg1S5oPv/QU=
-apigo.cc/go/encoding v1.0.4 h1:aezB0J/qFuHs6iXkbtuJP5JIHUtmjsr5SFb0NNvbObY=
-apigo.cc/go/encoding v1.0.4/go.mod h1:V5CgT7rBbCxy+uCU20q0ptcNNRSgMtpA8cNOs6r8IeI=
-apigo.cc/go/file v1.0.4 h1:qCKegV7OYh7r0qc3jZjGA/aKh0vIHgmr1OEbhfEmGX8=
-apigo.cc/go/file v1.0.4/go.mod h1:C9gNo7386iA21OiBmuWh6CznKWlVBDFkhE4f0H0Susg=
-apigo.cc/go/http v1.0.3 h1:c19ppdb7gR9aIPeY3qOjOj4X3+jZLXln76jTTj7i4vM=
-apigo.cc/go/http v1.0.3/go.mod h1:oHQYlBLN6u53C2t1BihxT7cnUQd+zLTAYr3ALjWUkpg=
-apigo.cc/go/id v1.0.4 h1:w+JSdeVit52iefIUolrh1qLEZS9XqHNKr1UygFcgv+s=
-apigo.cc/go/id v1.0.4/go.mod h1:kg7QuceAKtGNzGWt0+pIIh8Qom1eMSWGb8+0Yhi/QVY=
-apigo.cc/go/log v1.0.2 h1:OY6T3SC28blDNkMpdRvDK2N4sGdriAB9DBItGl/qOos=
-apigo.cc/go/log v1.0.2/go.mod h1:tvPgFpebY9Wf/DlqMHZ0ZjxDp9AaQTywOQKvtBaNqNo=
-apigo.cc/go/rand v1.0.4 h1:we070eWSL0dB8NEMaWjXj43+EekXQTm/h0kKpZ/frqw=
-apigo.cc/go/rand v1.0.4/go.mod h1:mZ/4Soa3bk+XvDaqPWJuUe1bfEi4eThBj1XmEAuYxsk=
-apigo.cc/go/redis v1.0.2 h1:gWBrL/6eDxtouTFSZrPKQNdEg1AZr2aKTpCOhwim3dI=
-apigo.cc/go/redis v1.0.2/go.mod h1:auQ3cyORgD67HF5dNvZ1lA8bqMH1xIbnuKBuZWclNy4=
-apigo.cc/go/safe v1.0.4 h1:07pRSdEHprF/2v6SsqAjICYFoeLcqjjvHGEdh6Dzrzg=
-apigo.cc/go/safe v1.0.4/go.mod h1:o568sHS5rTRSVPmhxWod0tGdc+8l1KjidsNY1/OVZr0=
-apigo.cc/go/shell v1.0.4 h1:EL9zjI39YBe1h+kRYQeAi/8zVGHe5W198DYYN7cENiY=
-apigo.cc/go/shell v1.0.4/go.mod h1:N2gDkgK4tJ9TadD60/+gAGuWxyVAWHs5YPBmytw6ELA=
+apigo.cc/go/cast v1.2.8 h1:plb676DH2TjYljzf8OEMGT6lIhmZ/xaxEFfs0kDOiSI=
+apigo.cc/go/cast v1.2.8/go.mod h1:lGlwImiOvHxG7buyMWhFzcdvQzmSaoKbmr7bcDfUpHk=
+apigo.cc/go/config v1.0.7 h1:lldkjsuUrWVHz/0y08/pF1vbsTvZC3TNQ2tFQ38jRNw=
+apigo.cc/go/config v1.0.7/go.mod h1:9oogTK83NvNmvAEIe/zuK2EKOnDtNz3bZoVqvyhFMW8=
+apigo.cc/go/crypto v1.1.0 h1:dv9ZRbtJHnnLbDHUfjP//GHLniu0/5ja0w5QE5hwwOU=
+apigo.cc/go/crypto v1.1.0/go.mod h1:0NUsQMGiP95TWHJexb3F1MxNdW+LR8TD1VqwHPN8PR8=
+apigo.cc/go/encoding v1.1.1 h1:p/57IfKIeB+b3rTfZSN3KegZigfPOEEfuuuOmZuc+sM=
+apigo.cc/go/encoding v1.1.1/go.mod h1:GeAz5OnCkFybTR1+GWFqdMgfq5v6r4MsjWVPOk/mpf4=
+apigo.cc/go/file v1.0.7 h1:j1VBtmMZqNGnH++DYjHecX1XAKTlKAuqUiUW1HafRas=
+apigo.cc/go/file v1.0.7/go.mod h1:2qC+p8p7iHx0DHAPubHXkLrEuLGO9WXTtdwyFjrSc1I=
+apigo.cc/go/http v1.0.9 h1:fDJ11Rj/GhigSR0ROSHm0oWJidBCZ56+B+ntoEtw6+g=
+apigo.cc/go/http v1.0.9/go.mod h1:ca9LYy3TURMUKKB5654ofpRgNqLaq5ibxOrWb5PgOiU=
+apigo.cc/go/id v1.0.5 h1:23YkR7oklSA69gthYlu8zl/kpIkeIoEYxi1f1Sz5l3A=
+apigo.cc/go/id v1.0.5/go.mod h1:ZaYLIyrJvkf3j7J8a0lnKywSAHljaczWxU0x2HmQDzg=
+apigo.cc/go/log v1.1.13 h1:ZABeVA9DxhdneLqHrYEc+6YijgoygG8eEsgDxYDzpDc=
+apigo.cc/go/log v1.1.13/go.mod h1:eabuI2SynGNgo5FXPbGgQtyxjp94wT643XzjYhEIP3A=
+apigo.cc/go/rand v1.0.5 h1:AkUoWr0SELgeDmRjLEDjOIp29nXdzqQQvmGRIHpTN7U=
+apigo.cc/go/rand v1.0.5/go.mod h1:mZ/4Soa3bk+XvDaqPWJuUe1bfEi4eThBj1XmEAuYxsk=
+apigo.cc/go/redis v1.0.7 h1:WFhbsjwIdUsmBcpMO45QTHlKu/nETpcRewLWqF5TnpQ=
+apigo.cc/go/redis v1.0.7/go.mod h1:gEgnzhrrlZHL6XzsKEG+zR2y6l/eWIbwdT1dbhbG/7g=
+apigo.cc/go/safe v1.0.5 h1:yZJLhpMntJrtqU/ev0UlyOoHu/cLrnnGUO4aHyIZcwE=
+apigo.cc/go/safe v1.0.5/go.mod h1:i9xnh7reJIFPauLnlzuIDgvrQvhjxpFlpVh3O6ulWd0=
+apigo.cc/go/shell v1.0.5 h1:bmvUTJGe1GwsHAy42v3iaoK40PoBC7Xq1aMCYxUZmtg=
+apigo.cc/go/shell v1.0.5/go.mod h1:sx/nYw5CihHWmo5JHkaZUbmMYXNHx8swzArbQCUGHjc=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/gomodule/redigo v1.9.3 h1:dNPSXeXv6HCq2jdyWfjgmhBdqnR6PRO3m/G05nvpPC8=
 github.com/gomodule/redigo v1.9.3/go.mod h1:KsU3hiK/Ay8U42qpaJk+kuNa3C+spxapWpM+ywhcgtw=
 github.com/gorilla/websocket v1.5.3 h1:saDtZ6Pbx/0u+bgYQ3q96pZgCzfhKXGPqt7kZ72aNNg=
 github.com/gorilla/websocket v1.5.3/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
+github.com/kr/pretty v0.3.0 h1:WgNl7dwNpEZ6jJ9k1snq4pZsg7DOEN8hP9Xw0Tsjwk0=
+github.com/kr/pretty v0.3.0/go.mod h1:640gp4NfQd8pI5XOwp5fnNeVWj67G7CFk/SaSQn7NBk=
+github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
+github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
-github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk=
-github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
+github.com/rogpeppe/go-internal v1.14.1 h1:UQB4HGPB6osV0SQTLymcB4TgvyWu6ZyliaW0tI/otEQ=
+github.com/rogpeppe/go-internal v1.14.1/go.mod h1:MaRKkUm5W0goXpeCfT7UZI6fk/L7L7so1lCWt35ZSgc=
+github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
+github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
 golang.org/x/crypto v0.50.0 h1:zO47/JPrL6vsNkINmLoo/PH1gcxpls50DNogFvB5ZGI=
 golang.org/x/crypto v0.50.0/go.mod h1:3muZ7vA7PBCE6xgPX7nkzzjiUq87kRItoJQM1Yo8S+Q=
+golang.org/x/crypto v0.51.0 h1:IBPXwPfKxY7cWQZ38ZCIRPI50YLeevDLlLnyC5wRGTI=
+golang.org/x/crypto v0.51.0/go.mod h1:8AdwkbraGNABw2kOX6YFPs3WM22XqI4EXEd8g+x7Oc8=
 golang.org/x/net v0.53.0 h1:d+qAbo5L0orcWAr0a9JweQpjXF19LMXJE8Ey7hwOdUA=
 golang.org/x/net v0.53.0/go.mod h1:JvMuJH7rrdiCfbeHoo3fCQU24Lf5JJwT9W3sJFulfgs=
+golang.org/x/net v0.54.0 h1:2zJIZAxAHV/OHCDTCOHAYehQzLfSXuf/5SoL/Dv6w/w=
+golang.org/x/net v0.54.0/go.mod h1:Sj4oj8jK6XmHpBZU/zWHw3BV3abl4Kvi+Ut7cQcY+cQ=
 golang.org/x/sys v0.43.0 h1:Rlag2XtaFTxp19wS8MXlJwTvoh8ArU6ezoyFsMyCTNI=
 golang.org/x/sys v0.43.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw=
+golang.org/x/sys v0.44.0 h1:ildZl3J4uzeKP07r2F++Op7E9B29JRUy+a27EibtBTQ=
+golang.org/x/sys v0.44.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw=
 golang.org/x/text v0.36.0 h1:JfKh3XmcRPqZPKevfXVpI1wXPTqbkE5f7JA92a55Yxg=
 golang.org/x/text v0.36.0/go.mod h1:NIdBknypM8iqVmPiuco0Dh6P5Jcdk8lJL0CUebqK164=
-gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
+golang.org/x/text v0.37.0 h1:Cqjiwd9eSg8e0QAkyCaQTNHFIIzWtidPahFWR83rTrc=
+golang.org/x/text v0.37.0/go.mod h1:a5sjxXGs9hsn/AJVwuElvCAo9v8QYLzvavO5z2PiM38=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
+gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
 gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=