灵隙(synapse) v1.0.0 版本
This commit is contained in:
521
internal/components/harbor/harbor.go
Normal file
521
internal/components/harbor/harbor.go
Normal file
@@ -0,0 +1,521 @@
|
||||
// Package harbor 灵泊 - 异步队列与暂存层
|
||||
//
|
||||
// "泊"为船舶停靠。数据包如远行之舟,
|
||||
// 遇风浪(网络抖动)时暂泊于此,
|
||||
// 待风平浪静(目标就绪)再启航。
|
||||
// 不丢包、不超时,给予 Agent 异步协作的从容。
|
||||
package harbor
|
||||
|
||||
import (
|
||||
"context"
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"log"
|
||||
"sync"
|
||||
"time"
|
||||
|
||||
"synapse/pkg/types"
|
||||
)
|
||||
|
||||
// =============================================================================
|
||||
// Message Queue - 消息队列
|
||||
// =============================================================================
|
||||
|
||||
// QueueType 队列类型
|
||||
type QueueType string
|
||||
|
||||
const (
|
||||
QueueFIFO QueueType = "fifo" // 先进先出
|
||||
QueuePriority QueueType = "priority" // 优先级队列
|
||||
QueueLIFO QueueType = "lifo" // 后进先出
|
||||
)
|
||||
|
||||
// QueuedMessage 队列中的消息
|
||||
type QueuedMessage struct {
|
||||
ID string
|
||||
Message *types.UnifiedSynapseMessage
|
||||
Priority int
|
||||
EnqueueTime time.Time
|
||||
RetryCount int
|
||||
MaxRetries int
|
||||
NextRetry time.Time
|
||||
Status QueuedStatus
|
||||
Target string // 目标 endpoint
|
||||
}
|
||||
|
||||
// QueuedStatus 队列消息状态
|
||||
type QueuedStatus string
|
||||
|
||||
const (
|
||||
QueuedPending QueuedStatus = "pending"
|
||||
QueuedProcessing QueuedStatus = "processing"
|
||||
QueuedDelivered QueuedStatus = "delivered"
|
||||
QueuedFailed QueuedStatus = "failed"
|
||||
QueuedDead QueuedStatus = "dead"
|
||||
)
|
||||
|
||||
// MessageQueue 消息队列
|
||||
type MessageQueue struct {
|
||||
mu sync.RWMutex
|
||||
messages []*QueuedMessage
|
||||
config *QueueConfig
|
||||
}
|
||||
|
||||
// QueueConfig 队列配置
|
||||
type QueueConfig struct {
|
||||
MaxSize int // 最大队列大小
|
||||
DefaultMaxRetries int // 默认最大重试次数
|
||||
DefaultRetryDelay time.Duration // 默认重试延迟
|
||||
}
|
||||
|
||||
// DefaultQueueConfig 返回默认队列配置
|
||||
func DefaultQueueConfig() *QueueConfig {
|
||||
return &QueueConfig{
|
||||
MaxSize: 10000,
|
||||
DefaultMaxRetries: 5,
|
||||
DefaultRetryDelay: 30 * time.Second,
|
||||
}
|
||||
}
|
||||
|
||||
// NewMessageQueue 创建消息队列
|
||||
func NewMessageQueue(config *QueueConfig) *MessageQueue {
|
||||
if config == nil {
|
||||
config = DefaultQueueConfig()
|
||||
}
|
||||
return &MessageQueue{
|
||||
messages: make([]*QueuedMessage, 0),
|
||||
config: config,
|
||||
}
|
||||
}
|
||||
|
||||
// Enqueue 入队
|
||||
func (mq *MessageQueue) Enqueue(msg *types.UnifiedSynapseMessage, target string, priority int) (*QueuedMessage, error) {
|
||||
mq.mu.Lock()
|
||||
defer mq.mu.Unlock()
|
||||
|
||||
if len(mq.messages) >= mq.config.MaxSize {
|
||||
return nil, fmt.Errorf("queue is full")
|
||||
}
|
||||
|
||||
qm := &QueuedMessage{
|
||||
ID: fmt.Sprintf("q-%d", time.Now().UnixNano()),
|
||||
Message: msg,
|
||||
Priority: priority,
|
||||
EnqueueTime: time.Now(),
|
||||
RetryCount: 0,
|
||||
MaxRetries: mq.config.DefaultMaxRetries,
|
||||
NextRetry: time.Now(),
|
||||
Status: QueuedPending,
|
||||
Target: target,
|
||||
}
|
||||
|
||||
// 按优先级插入
|
||||
inserted := false
|
||||
for i, m := range mq.messages {
|
||||
if priority > m.Priority {
|
||||
mq.messages = append(mq.messages[:i], append([]*QueuedMessage{qm}, mq.messages[i:]...)...)
|
||||
inserted = true
|
||||
break
|
||||
}
|
||||
}
|
||||
if !inserted {
|
||||
mq.messages = append(mq.messages, qm)
|
||||
}
|
||||
|
||||
log.Printf("[灵泊] 消息入队: %s (目标: %s, 优先级: %d)", qm.ID, target, priority)
|
||||
return qm, nil
|
||||
}
|
||||
|
||||
// Dequeue 出队
|
||||
func (mq *MessageQueue) Dequeue() (*QueuedMessage, error) {
|
||||
mq.mu.Lock()
|
||||
defer mq.mu.Unlock()
|
||||
|
||||
now := time.Now()
|
||||
for i, qm := range mq.messages {
|
||||
if qm.Status == QueuedPending && now.After(qm.NextRetry) {
|
||||
qm.Status = QueuedProcessing
|
||||
// 移到待处理
|
||||
mq.messages = append(mq.messages[:i], mq.messages[i+1:]...)
|
||||
return qm, nil
|
||||
}
|
||||
}
|
||||
|
||||
return nil, fmt.Errorf("no messages available")
|
||||
}
|
||||
|
||||
// MarkDelivered 标记为已送达
|
||||
func (mq *MessageQueue) MarkDelivered(msgID string) error {
|
||||
mq.mu.Lock()
|
||||
defer mq.mu.Unlock()
|
||||
|
||||
for _, qm := range mq.messages {
|
||||
if qm.ID == msgID {
|
||||
qm.Status = QueuedDelivered
|
||||
log.Printf("[灵泊] 消息送达: %s", msgID)
|
||||
return nil
|
||||
}
|
||||
}
|
||||
return fmt.Errorf("message %s not found", msgID)
|
||||
}
|
||||
|
||||
// MarkFailed 标记为失败(会重试)
|
||||
func (mq *MessageQueue) MarkFailed(msgID string, err error) error {
|
||||
mq.mu.Lock()
|
||||
defer mq.mu.Unlock()
|
||||
|
||||
for _, qm := range mq.messages {
|
||||
if qm.ID == msgID {
|
||||
qm.RetryCount++
|
||||
if qm.RetryCount >= qm.MaxRetries {
|
||||
qm.Status = QueuedDead
|
||||
log.Printf("[灵泊] 消息失败(已死): %s (重试: %d次)", msgID, qm.RetryCount)
|
||||
} else {
|
||||
qm.Status = QueuedPending
|
||||
// 指数退避
|
||||
delay := mq.config.DefaultRetryDelay * time.Duration(1<<uint(qm.RetryCount-1))
|
||||
qm.NextRetry = time.Now().Add(delay)
|
||||
log.Printf("[灵泊] 消息失败(将重试): %s (重试: %d/%d, 下次: %v)",
|
||||
msgID, qm.RetryCount, qm.MaxRetries, delay)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
}
|
||||
return fmt.Errorf("message %s not found", msgID)
|
||||
}
|
||||
|
||||
// Size 队列大小
|
||||
func (mq *MessageQueue) Size() int {
|
||||
mq.mu.RLock()
|
||||
defer mq.mu.RUnlock()
|
||||
return len(mq.messages)
|
||||
}
|
||||
|
||||
// =============================================================================
|
||||
// Message Buffer - 消息缓冲
|
||||
// =============================================================================
|
||||
|
||||
// MessageBuffer 消息缓冲(暂存离线消息)
|
||||
type MessageBuffer struct {
|
||||
mu sync.RWMutex
|
||||
buffers map[string][]*types.UnifiedSynapseMessage // agent_id -> messages
|
||||
config *BufferConfig
|
||||
}
|
||||
|
||||
// BufferConfig 缓冲配置
|
||||
type BufferConfig struct {
|
||||
MaxPerAgent int // 每个 Agent 最大缓冲数
|
||||
MaxAge time.Duration // 消息最大存活时间
|
||||
CleanupInterval time.Duration // 清理间隔
|
||||
}
|
||||
|
||||
// DefaultBufferConfig 返回默认缓冲配置
|
||||
func DefaultBufferConfig() *BufferConfig {
|
||||
return &BufferConfig{
|
||||
MaxPerAgent: 1000,
|
||||
MaxAge: 24 * time.Hour,
|
||||
CleanupInterval: 1 * time.Hour,
|
||||
}
|
||||
}
|
||||
|
||||
// NewMessageBuffer 创建消息缓冲
|
||||
func NewMessageBuffer(config *BufferConfig) *MessageBuffer {
|
||||
if config == nil {
|
||||
config = DefaultBufferConfig()
|
||||
}
|
||||
mb := &MessageBuffer{
|
||||
buffers: make(map[string][]*types.UnifiedSynapseMessage),
|
||||
config: config,
|
||||
}
|
||||
|
||||
// 启动清理协程
|
||||
go mb.cleanupLoop()
|
||||
|
||||
return mb
|
||||
}
|
||||
|
||||
// BufferMessage 缓冲消息
|
||||
func (mb *MessageBuffer) BufferMessage(agentID string, msg *types.UnifiedSynapseMessage) error {
|
||||
mb.mu.Lock()
|
||||
defer mb.mu.Unlock()
|
||||
|
||||
buf, ok := mb.buffers[agentID]
|
||||
if !ok {
|
||||
buf = make([]*types.UnifiedSynapseMessage, 0)
|
||||
}
|
||||
|
||||
if len(buf) >= mb.config.MaxPerAgent {
|
||||
// 丢弃最旧的
|
||||
buf = buf[1:]
|
||||
}
|
||||
|
||||
mb.buffers[agentID] = append(buf, msg)
|
||||
|
||||
log.Printf("[灵泊] 缓冲消息: %s -> %s (缓冲区大小: %d)",
|
||||
msg.Sender.AgentID, agentID, len(mb.buffers[agentID]))
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
// FlushBuffer 清空缓冲并返回所有消息
|
||||
func (mb *MessageBuffer) FlushBuffer(agentID string) []*types.UnifiedSynapseMessage {
|
||||
mb.mu.Lock()
|
||||
defer mb.mu.Unlock()
|
||||
|
||||
buf, ok := mb.buffers[agentID]
|
||||
if !ok {
|
||||
return []*types.UnifiedSynapseMessage{}
|
||||
}
|
||||
|
||||
delete(mb.buffers, agentID)
|
||||
|
||||
log.Printf("[灵泊] 清空缓冲: %s (消息数: %d)", agentID, len(buf))
|
||||
return buf
|
||||
}
|
||||
|
||||
// GetBufferSize 获取缓冲大小
|
||||
func (mb *MessageBuffer) GetBufferSize(agentID string) int {
|
||||
mb.mu.RLock()
|
||||
defer mb.mu.RUnlock()
|
||||
return len(mb.buffers[agentID])
|
||||
}
|
||||
|
||||
// cleanupLoop 清理过期消息
|
||||
func (mb *MessageBuffer) cleanupLoop() {
|
||||
ticker := time.NewTicker(mb.config.CleanupInterval)
|
||||
defer ticker.Stop()
|
||||
|
||||
for range ticker.C {
|
||||
mb.cleanup()
|
||||
}
|
||||
}
|
||||
|
||||
func (mb *MessageBuffer) cleanup() {
|
||||
mb.mu.Lock()
|
||||
defer mb.mu.Unlock()
|
||||
|
||||
now := time.Now()
|
||||
cleaned := 0
|
||||
|
||||
for agentID, buf := range mb.buffers {
|
||||
var newBuf []*types.UnifiedSynapseMessage
|
||||
for _, msg := range buf {
|
||||
msgTime, _ := time.Parse(time.RFC3339, string(msg.Timestamp))
|
||||
if now.Sub(msgTime) < mb.config.MaxAge {
|
||||
newBuf = append(newBuf, msg)
|
||||
} else {
|
||||
cleaned++
|
||||
}
|
||||
}
|
||||
mb.buffers[agentID] = newBuf
|
||||
}
|
||||
|
||||
if cleaned > 0 {
|
||||
log.Printf("[灵泊] 清理过期消息: %d 条", cleaned)
|
||||
}
|
||||
}
|
||||
|
||||
// =============================================================================
|
||||
// Retry Manager - 重试管理器
|
||||
// =============================================================================
|
||||
|
||||
// RetryManager 重试管理器
|
||||
type RetryManager struct {
|
||||
mu sync.RWMutex
|
||||
retries map[string]*RetryEntry
|
||||
config *RetryConfig
|
||||
}
|
||||
|
||||
// RetryEntry 重试条目
|
||||
type RetryEntry struct {
|
||||
ID string
|
||||
Message *types.UnifiedSynapseMessage
|
||||
Target string
|
||||
RetryCount int
|
||||
MaxRetries int
|
||||
NextRetry time.Time
|
||||
LastError string
|
||||
BackoffBase time.Duration
|
||||
}
|
||||
|
||||
// RetryConfig 重试配置
|
||||
type RetryConfig struct {
|
||||
MaxRetries int
|
||||
BaseDelay time.Duration
|
||||
MaxDelay time.Duration
|
||||
JitterFactor float64
|
||||
}
|
||||
|
||||
// DefaultRetryConfig 返回默认重试配置
|
||||
func DefaultRetryConfig() *RetryConfig {
|
||||
return &RetryConfig{
|
||||
MaxRetries: 5,
|
||||
BaseDelay: 1 * time.Second,
|
||||
MaxDelay: 5 * time.Minute,
|
||||
JitterFactor: 0.1,
|
||||
}
|
||||
}
|
||||
|
||||
// NewRetryManager 创建重试管理器
|
||||
func NewRetryManager(config *RetryConfig) *RetryManager {
|
||||
if config == nil {
|
||||
config = DefaultRetryConfig()
|
||||
}
|
||||
return &RetryManager{
|
||||
retries: make(map[string]*RetryEntry),
|
||||
config: config,
|
||||
}
|
||||
}
|
||||
|
||||
// AddRetry 添加重试条目
|
||||
func (rm *RetryManager) AddRetry(msg *types.UnifiedSynapseMessage, target string) {
|
||||
rm.mu.Lock()
|
||||
defer rm.mu.Unlock()
|
||||
|
||||
id := fmt.Sprintf("retry-%d", time.Now().UnixNano())
|
||||
entry := &RetryEntry{
|
||||
ID: id,
|
||||
Message: msg,
|
||||
Target: target,
|
||||
RetryCount: 0,
|
||||
MaxRetries: rm.config.MaxRetries,
|
||||
NextRetry: time.Now().Add(rm.config.BaseDelay),
|
||||
BackoffBase: rm.config.BaseDelay,
|
||||
}
|
||||
|
||||
rm.retries[id] = entry
|
||||
|
||||
log.Printf("[灵泊] 添加重试: %s -> %s (最多 %d 次)", id, target, rm.config.MaxRetries)
|
||||
}
|
||||
|
||||
// GetPendingRetries 获取待重试的条目
|
||||
func (rm *RetryManager) GetPendingRetries() []*RetryEntry {
|
||||
rm.mu.RLock()
|
||||
defer rm.mu.RUnlock()
|
||||
|
||||
now := time.Now()
|
||||
var pending []*RetryEntry
|
||||
for _, entry := range rm.retries {
|
||||
if now.After(entry.NextRetry) && entry.RetryCount < entry.MaxRetries {
|
||||
pending = append(pending, entry)
|
||||
}
|
||||
}
|
||||
return pending
|
||||
}
|
||||
|
||||
// MarkSuccess 标记成功
|
||||
func (rm *RetryManager) MarkSuccess(retryID string) {
|
||||
rm.mu.Lock()
|
||||
defer rm.mu.Unlock()
|
||||
delete(rm.retries, retryID)
|
||||
log.Printf("[灵泊] 重试成功: %s", retryID)
|
||||
}
|
||||
|
||||
// MarkFailure 标记失败
|
||||
func (rm *RetryManager) MarkFailure(retryID string, err error) bool {
|
||||
rm.mu.Lock()
|
||||
defer rm.mu.Unlock()
|
||||
|
||||
entry, ok := rm.retries[retryID]
|
||||
if !ok {
|
||||
return false
|
||||
}
|
||||
|
||||
entry.RetryCount++
|
||||
entry.LastError = err.Error()
|
||||
|
||||
if entry.RetryCount >= entry.MaxRetries {
|
||||
delete(rm.retries, retryID)
|
||||
log.Printf("[灵泊] 重试失败(已达上限): %s (重试 %d 次)", retryID, entry.RetryCount)
|
||||
return false
|
||||
}
|
||||
|
||||
// 指数退避 + 抖动
|
||||
delay := entry.BackoffBase * time.Duration(1<<uint(entry.RetryCount-1))
|
||||
if delay > rm.config.MaxDelay {
|
||||
delay = rm.config.MaxDelay
|
||||
}
|
||||
entry.NextRetry = time.Now().Add(delay)
|
||||
|
||||
log.Printf("[灵泊] 重试失败: %s (%d/%d, 下次: %v)",
|
||||
retryID, entry.RetryCount, entry.MaxRetries, delay)
|
||||
|
||||
return true
|
||||
}
|
||||
|
||||
// Stats 获取统计信息
|
||||
func (rm *RetryManager) Stats() (pending, failed int) {
|
||||
rm.mu.RLock()
|
||||
defer rm.mu.RUnlock()
|
||||
for _, entry := range rm.retries {
|
||||
if entry.RetryCount == 0 {
|
||||
pending++
|
||||
}
|
||||
}
|
||||
return pending, 0
|
||||
}
|
||||
|
||||
// =============================================================================
|
||||
// Harbor - 灵泊整体入口
|
||||
// =============================================================================
|
||||
|
||||
// Harbor 灵泊 - 异步队列与暂存
|
||||
type Harbor struct {
|
||||
Queue *MessageQueue
|
||||
Buffer *MessageBuffer
|
||||
Retry *RetryManager
|
||||
}
|
||||
|
||||
// NewHarbor 创建灵泊
|
||||
func NewHarbor() *Harbor {
|
||||
return &Harbor{
|
||||
Queue: NewMessageQueue(nil),
|
||||
Buffer: NewMessageBuffer(nil),
|
||||
Retry: NewRetryManager(nil),
|
||||
}
|
||||
}
|
||||
|
||||
// SendWithRetry 发送消息并重试
|
||||
func (h *Harbor) SendWithRetry(ctx context.Context, msg *types.UnifiedSynapseMessage, target string, sendFunc func(ctx context.Context, msg *types.UnifiedSynapseMessage, target string) error) error {
|
||||
// 先入队
|
||||
qm, err := h.Queue.Enqueue(msg, target, 5)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
// 尝试发送
|
||||
err = sendFunc(ctx, msg, target)
|
||||
if err == nil {
|
||||
h.Queue.MarkDelivered(qm.ID)
|
||||
return nil
|
||||
}
|
||||
|
||||
// 失败,加入重试
|
||||
h.Retry.AddRetry(msg, target)
|
||||
h.Queue.MarkFailed(qm.ID, err)
|
||||
|
||||
return err
|
||||
}
|
||||
|
||||
// BufferForOffline 为离线 Agent 缓冲消息
|
||||
func (h *Harbor) BufferForOffline(agentID string, msg *types.UnifiedSynapseMessage) {
|
||||
h.Buffer.BufferMessage(agentID, msg)
|
||||
}
|
||||
|
||||
// FlushAndSend 清空缓冲并发送
|
||||
func (h *Harbor) FlushAndSend(agentID string, sendFunc func(msg *types.UnifiedSynapseMessage) error) int {
|
||||
msgs := h.Buffer.FlushBuffer(agentID)
|
||||
sent := 0
|
||||
for _, msg := range msgs {
|
||||
if err := sendFunc(msg); err == nil {
|
||||
sent++
|
||||
}
|
||||
}
|
||||
return sent
|
||||
}
|
||||
|
||||
// ToJSON 导出为 JSON
|
||||
func (qm *QueuedMessage) ToJSON() string {
|
||||
data, _ := json.MarshalIndent(qm, "", " ")
|
||||
return string(data)
|
||||
}
|
||||
Reference in New Issue
Block a user