314 lines
7.5 KiB
Go
314 lines
7.5 KiB
Go
package message
|
||
|
||
import (
|
||
"context"
|
||
"fmt"
|
||
"sync"
|
||
"sync/atomic"
|
||
"time"
|
||
|
||
"github.com/gogf/gf/v2/frame/g"
|
||
"github.com/nats-io/nats.go"
|
||
"github.com/nats-io/nats.go/jetstream"
|
||
)
|
||
|
||
var (
|
||
nc *nats.Conn
|
||
js jetstream.JetStream
|
||
inited bool
|
||
natsMu sync.RWMutex
|
||
natsURL string
|
||
healthCtx context.Context
|
||
healthCancel context.CancelFunc
|
||
connected bool
|
||
reconnectChan chan struct{}
|
||
|
||
// 连接状态变化监听器
|
||
connStateListeners []connStateListener
|
||
connListenersMu sync.RWMutex
|
||
|
||
// 监控指标
|
||
metrics metricsCounter
|
||
)
|
||
|
||
// Metrics 监控指标
|
||
type metricsCounter struct {
|
||
PublishCount atomic.Int64
|
||
PublishError atomic.Int64
|
||
SubscribeCount atomic.Int64
|
||
RequestCount atomic.Int64
|
||
RequestError atomic.Int64
|
||
ConsumeCount atomic.Int64
|
||
ConsumeError atomic.Int64
|
||
}
|
||
|
||
// ConnState 连接状态
|
||
type connState int
|
||
|
||
const (
|
||
connStateDisconnected connState = iota
|
||
connStateConnecting
|
||
connStateConnected
|
||
connStateReconnecting
|
||
connStateClosed
|
||
)
|
||
|
||
// ConnStateListener 连接状态监听器
|
||
type connStateListener func(state connState, err error)
|
||
|
||
// GetMetrics 获取监控指标
|
||
func getMetrics() metricsCounter {
|
||
return metrics
|
||
}
|
||
|
||
// registerConnStateListener 注册连接状态监听器
|
||
func registerConnStateListener(listener connStateListener) {
|
||
connListenersMu.Lock()
|
||
defer connListenersMu.Unlock()
|
||
connStateListeners = append(connStateListeners, listener)
|
||
}
|
||
|
||
// unregisterConnStateListener 取消注册连接状态监听器
|
||
func unregisterConnStateListener(listener connStateListener) {
|
||
connListenersMu.Lock()
|
||
defer connListenersMu.Unlock()
|
||
for i, l := range connStateListeners {
|
||
if l != nil && &l == &listener {
|
||
connStateListeners = append(connStateListeners[:i], connStateListeners[i+1:]...)
|
||
break
|
||
}
|
||
}
|
||
}
|
||
|
||
// notifyConnState 通知所有监听器连接状态变化
|
||
func notifyConnState(state connState, err error) {
|
||
connListenersMu.RLock()
|
||
listeners := make([]connStateListener, len(connStateListeners))
|
||
copy(listeners, connStateListeners)
|
||
connListenersMu.RUnlock()
|
||
|
||
for _, listener := range listeners {
|
||
if listener != nil {
|
||
listener(state, err)
|
||
}
|
||
}
|
||
}
|
||
|
||
// init 初始化 NATS 连接
|
||
func init() {
|
||
// 从配置文件读取 NATS 地址
|
||
natsURL = g.Cfg().MustGet(context.Background(), "nats.url").String()
|
||
if natsURL == "" {
|
||
// 默认使用本地地址
|
||
natsURL = nats.DefaultURL
|
||
}
|
||
|
||
// 创建健康检查上下文
|
||
healthCtx, healthCancel = context.WithCancel(context.Background())
|
||
|
||
// 创建重连通知通道（增大缓冲区避免丢失通知）
|
||
reconnectChan = make(chan struct{}, 10)
|
||
|
||
// 启动连接
|
||
go initConnection()
|
||
|
||
// 启动健康检查协程
|
||
go healthCheck()
|
||
}
|
||
|
||
// initConnection 初始化连接
|
||
func initConnection() {
|
||
ctx := context.Background()
|
||
notifyConnState(connStateConnecting, nil)
|
||
if err := connect(ctx); err != nil {
|
||
g.Log().Errorf(ctx, "NATS 初始连接失败: %v", err)
|
||
notifyConnState(connStateDisconnected, err)
|
||
}
|
||
}
|
||
|
||
// connect 建立 NATS 连接
|
||
func connect(ctx context.Context) error {
|
||
natsMu.Lock()
|
||
defer natsMu.Unlock()
|
||
|
||
if nc != nil && !nc.IsClosed() {
|
||
nc.Close()
|
||
}
|
||
|
||
// 连接选项配置
|
||
opts := []nats.Option{
|
||
nats.Name("goframe-nats-client"),
|
||
nats.ReconnectWait(2 * time.Second),
|
||
nats.MaxReconnects(-1), // 无限重连
|
||
nats.PingInterval(10 * time.Second),
|
||
nats.MaxPingsOutstanding(5),
|
||
nats.ReconnectHandler(func(nc *nats.Conn) {
|
||
g.Log().Infof(ctx, "✅ NATS 重连成功: %s", nc.ConnectedUrl())
|
||
connected = true
|
||
|
||
// 重新创建 JetStream 实例
|
||
if newJS, err := jetstream.New(nc); err == nil {
|
||
js = newJS
|
||
}
|
||
|
||
// 通知重连成功
|
||
notifyConnState(connStateConnected, nil)
|
||
|
||
// 使用非阻塞发送避免阻塞
|
||
select {
|
||
case reconnectChan <- struct{}{}:
|
||
default:
|
||
// 通道已满，丢弃通知
|
||
}
|
||
}),
|
||
nats.DisconnectErrHandler(func(nc *nats.Conn, err error) {
|
||
g.Log().Warningf(ctx, "⚠️ NATS 连接断开: %v, 准备重连...", err)
|
||
connected = false
|
||
notifyConnState(connStateReconnecting, err)
|
||
}),
|
||
nats.ClosedHandler(func(nc *nats.Conn) {
|
||
g.Log().Infof(ctx, "NATS 连接已关闭: %s", nc.ConnectedUrl())
|
||
connected = false
|
||
notifyConnState(connStateClosed, nil)
|
||
}),
|
||
nats.ErrorHandler(func(nc *nats.Conn, sub *nats.Subscription, err error) {
|
||
g.Log().Errorf(ctx, "NATS 错误: %v", err)
|
||
}),
|
||
}
|
||
|
||
var err error
|
||
nc, err = nats.Connect(natsURL, opts...)
|
||
if err != nil {
|
||
return fmt.Errorf("NATS 连接失败: %w", err)
|
||
}
|
||
|
||
// 等待连接就绪
|
||
if nc.Status() != nats.CONNECTED {
|
||
select {
|
||
case <-time.After(5 * time.Second):
|
||
notifyConnState(connStateDisconnected, fmt.Errorf("连接超时"))
|
||
return fmt.Errorf("NATS 连接超时")
|
||
case <-nc.StatusChanged(nats.CONNECTED):
|
||
}
|
||
}
|
||
|
||
// 创建 JetStream 实例
|
||
js, err = jetstream.New(nc)
|
||
if err != nil {
|
||
return fmt.Errorf("创建 JetStream 失败: %w", err)
|
||
}
|
||
|
||
connected = true
|
||
inited = true
|
||
g.Log().Infof(ctx, "✅ NATS 连接成功: %s", nc.ConnectedUrl())
|
||
notifyConnState(connStateConnected, nil)
|
||
return nil
|
||
}
|
||
|
||
// healthCheck 健康检查协程（仅作为备用检查）
|
||
func healthCheck() {
|
||
ticker := time.NewTicker(30 * time.Second)
|
||
defer ticker.Stop()
|
||
|
||
for {
|
||
select {
|
||
case <-healthCtx.Done():
|
||
return
|
||
case <-ticker.C:
|
||
natsMu.RLock()
|
||
currentConnected := connected
|
||
currentConn := nc
|
||
natsMu.RUnlock()
|
||
|
||
if !currentConnected || currentConn == nil || currentConn.IsClosed() {
|
||
// 仅记录日志，不尝试重连（NATS 已有自动重连机制）
|
||
g.Log().Warning(context.Background(), "NATS 连接断开，等待 NATS 自动重连...")
|
||
}
|
||
case <-reconnectChan:
|
||
// 重连成功的通知（仅记录日志）
|
||
g.Log().Info(context.Background(), "收到重连成功通知")
|
||
}
|
||
}
|
||
}
|
||
|
||
// checkConnected 检查连接状态
|
||
func checkConnected() bool {
|
||
natsMu.RLock()
|
||
defer natsMu.RUnlock()
|
||
return connected && nc != nil && !nc.IsClosed()
|
||
}
|
||
|
||
// getConnState 获取当前连接状态
|
||
func getConnState() connState {
|
||
natsMu.RLock()
|
||
defer natsMu.RUnlock()
|
||
|
||
if nc == nil {
|
||
return connStateDisconnected
|
||
}
|
||
|
||
if nc.IsClosed() {
|
||
return connStateClosed
|
||
}
|
||
|
||
if connected {
|
||
return connStateConnected
|
||
}
|
||
|
||
return connStateDisconnected
|
||
}
|
||
|
||
// shutdown 优雅关闭：自动注销所有已注册的服务并关闭 NATS 连接
|
||
func shutdown() error {
|
||
ctx := context.Background()
|
||
g.Log().Info(ctx, "开始优雅关闭 NATS RPC 服务...")
|
||
|
||
// 注销所有单实例服务
|
||
rpcServicesMu.Lock()
|
||
singleServiceCount := len(rpcServices)
|
||
for serviceName := range rpcServices {
|
||
if sub, exists := rpcSubs[serviceName]; exists {
|
||
if err := sub.Unsubscribe(); err != nil {
|
||
g.Log().Errorf(ctx, "注销服务 %s 失败: %v", serviceName, err)
|
||
}
|
||
}
|
||
delete(rpcSubs, serviceName)
|
||
delete(rpcServices, serviceName)
|
||
}
|
||
rpcServicesMu.Unlock()
|
||
|
||
// 注销所有队列服务
|
||
queueRPCMu.Lock()
|
||
queueServiceCount := 0
|
||
for queueName, servicesMap := range queueRPCServices {
|
||
queueServiceCount += len(servicesMap)
|
||
for serviceName, sub := range queueRPCSubs[queueName] {
|
||
if err := sub.Unsubscribe(); err != nil {
|
||
g.Log().Errorf(ctx, "注销队列服务 %s (队列: %s) 失败: %v", serviceName, queueName, err)
|
||
}
|
||
}
|
||
delete(queueRPCSubs, queueName)
|
||
delete(queueRPCServices, queueName)
|
||
}
|
||
queueRPCMu.Unlock()
|
||
|
||
g.Log().Infof(ctx, "已注销 %d 个单实例服务和 %d 个队列服务", singleServiceCount, queueServiceCount)
|
||
|
||
natsMu.Lock()
|
||
defer natsMu.Unlock()
|
||
|
||
// 停止健康检查协程
|
||
if healthCancel != nil {
|
||
healthCancel()
|
||
}
|
||
|
||
// 关闭连接
|
||
if nc != nil && !nc.IsClosed() {
|
||
nc.Close()
|
||
connected = false
|
||
inited = false
|
||
}
|
||
g.Log().Info(ctx, "NATS RPC 服务已优雅关闭")
|
||
return nil
|
||
}
|