504 lines
12 KiB
Go
504 lines
12 KiB
Go
// Package pivot 灵枢 - 紧急制动与治理层
|
||
//
|
||
// 取自《灵枢经》（黄帝内经下半部），
|
||
// 讲的是针灸经络之枢纽。
|
||
// 这是整个协议的"总闸"与"方向盘"，
|
||
// 不轻易触发，但触发时能以最小代价
|
||
// 重置整个 Synapse 网络的状态。
|
||
package pivot
|
||
|
||
import (
|
||
"context"
|
||
"encoding/json"
|
||
"fmt"
|
||
"log"
|
||
"sync"
|
||
"time"
|
||
|
||
"synapse/pkg/types"
|
||
)
|
||
|
||
// =============================================================================
|
||
// Circuit Breaker - 熔断器
|
||
// =============================================================================
|
||
|
||
// CircuitState 熔断器状态
|
||
type CircuitState string
|
||
|
||
const (
|
||
CircuitClosed CircuitState = "closed" // 关闭：正常流通
|
||
CircuitOpen CircuitState = "open" // 打开：熔断，拒绝请求
|
||
CircuitHalfOpen CircuitState = "half_open" // 半开：尝试恢复
|
||
)
|
||
|
||
// CircuitBreaker 熔断器
|
||
type CircuitBreaker struct {
|
||
mu sync.RWMutex
|
||
name string
|
||
state CircuitState
|
||
failureCount int
|
||
successCount int
|
||
threshold int // 失败阈值
|
||
timeout time.Duration // 熔断超时
|
||
lastFailure time.Time
|
||
lastSuccess time.Time
|
||
}
|
||
|
||
// CircuitBreakerConfig 熔断器配置
|
||
type CircuitBreakerConfig struct {
|
||
Threshold int
|
||
Timeout time.Duration
|
||
}
|
||
|
||
// DefaultCircuitBreakerConfig 返回默认熔断器配置
|
||
func DefaultCircuitBreakerConfig() *CircuitBreakerConfig {
|
||
return &CircuitBreakerConfig{
|
||
Threshold: 5,
|
||
Timeout: 30 * time.Second,
|
||
}
|
||
}
|
||
|
||
// NewCircuitBreaker 创建熔断器
|
||
func NewCircuitBreaker(name string, config *CircuitBreakerConfig) *CircuitBreaker {
|
||
if config == nil {
|
||
config = DefaultCircuitBreakerConfig()
|
||
}
|
||
return &CircuitBreaker{
|
||
name: name,
|
||
state: CircuitClosed,
|
||
threshold: config.Threshold,
|
||
timeout: config.Timeout,
|
||
}
|
||
}
|
||
|
||
// Allow 是否允许请求通过
|
||
func (cb *CircuitBreaker) Allow() bool {
|
||
cb.mu.RLock()
|
||
defer cb.mu.RUnlock()
|
||
|
||
switch cb.state {
|
||
case CircuitClosed:
|
||
return true
|
||
case CircuitOpen:
|
||
// 检查是否超时，可以进入半开状态
|
||
if time.Since(cb.lastFailure) > cb.timeout {
|
||
cb.mu.RUnlock()
|
||
cb.mu.Lock()
|
||
if cb.state == CircuitOpen && time.Since(cb.lastFailure) > cb.timeout {
|
||
cb.state = CircuitHalfOpen
|
||
cb.successCount = 0
|
||
log.Printf("[灵枢] 熔断器 %s 进入半开状态", cb.name)
|
||
}
|
||
cb.mu.Unlock()
|
||
cb.mu.RLock()
|
||
return cb.state == CircuitHalfOpen
|
||
}
|
||
return false
|
||
case CircuitHalfOpen:
|
||
return true
|
||
default:
|
||
return false
|
||
}
|
||
}
|
||
|
||
// RecordSuccess 记录成功
|
||
func (cb *CircuitBreaker) RecordSuccess() {
|
||
cb.mu.Lock()
|
||
defer cb.mu.Unlock()
|
||
|
||
cb.lastSuccess = time.Now()
|
||
|
||
switch cb.state {
|
||
case CircuitHalfOpen:
|
||
cb.successCount++
|
||
// 连续成功几次后关闭熔断
|
||
if cb.successCount >= 3 {
|
||
cb.state = CircuitClosed
|
||
cb.failureCount = 0
|
||
cb.successCount = 0
|
||
log.Printf("[灵枢] 熔断器 %s 恢复关闭", cb.name)
|
||
}
|
||
case CircuitClosed:
|
||
cb.failureCount = 0
|
||
}
|
||
}
|
||
|
||
// RecordFailure 记录失败
|
||
func (cb *CircuitBreaker) RecordFailure() {
|
||
cb.mu.Lock()
|
||
defer cb.mu.Unlock()
|
||
|
||
cb.failureCount++
|
||
cb.lastFailure = time.Now()
|
||
|
||
switch cb.state {
|
||
case CircuitClosed:
|
||
if cb.failureCount >= cb.threshold {
|
||
cb.state = CircuitOpen
|
||
log.Printf("[灵枢] 熔断器 %s 触发熔断 (失败: %d次)", cb.name, cb.failureCount)
|
||
}
|
||
case CircuitHalfOpen:
|
||
cb.state = CircuitOpen
|
||
log.Printf("[灵枢] 熔断器 %s 半开失败，重新熔断", cb.name)
|
||
}
|
||
}
|
||
|
||
// State 获取当前状态
|
||
func (cb *CircuitBreaker) State() CircuitState {
|
||
cb.mu.RLock()
|
||
defer cb.mu.RUnlock()
|
||
return cb.state
|
||
}
|
||
|
||
// Reset 重置熔断器
|
||
func (cb *CircuitBreaker) Reset() {
|
||
cb.mu.Lock()
|
||
defer cb.mu.Unlock()
|
||
|
||
cb.state = CircuitClosed
|
||
cb.failureCount = 0
|
||
cb.successCount = 0
|
||
log.Printf("[灵枢] 熔断器 %s 已重置", cb.name)
|
||
}
|
||
|
||
// =============================================================================
|
||
// Governance - 治理
|
||
// =============================================================================
|
||
|
||
// GovernanceLevel 治理级别
|
||
type GovernanceLevel int
|
||
|
||
const (
|
||
GovLevelNormal GovernanceLevel = iota // 正常运行
|
||
GovLevelWatch // 观察模式
|
||
GovLevelRestricted // 受限模式
|
||
GovLevelEmergency // 紧急模式
|
||
GovLevelShutdown // 停机模式
|
||
)
|
||
|
||
func (l GovernanceLevel) String() string {
|
||
switch l {
|
||
case GovLevelNormal:
|
||
return "normal"
|
||
case GovLevelWatch:
|
||
return "watch"
|
||
case GovLevelRestricted:
|
||
return "restricted"
|
||
case GovLevelEmergency:
|
||
return "emergency"
|
||
case GovLevelShutdown:
|
||
return "shutdown"
|
||
default:
|
||
return "unknown"
|
||
}
|
||
}
|
||
|
||
// GovernanceManager 治理管理器
|
||
type GovernanceManager struct {
|
||
mu sync.RWMutex
|
||
level GovernanceLevel
|
||
policies map[string]GovernancePolicy
|
||
blacklist map[string]bool // 被封禁的 agent_id
|
||
whitelist map[string]bool // 白名单
|
||
config *GovernanceConfig
|
||
}
|
||
|
||
// GovernancePolicy 治理策略
|
||
type GovernancePolicy struct {
|
||
ID string
|
||
Name string
|
||
Description string
|
||
Enabled bool
|
||
Level GovernanceLevel
|
||
Evaluate func(ctx context.Context, msg *types.UnifiedSynapseMessage) (bool, string)
|
||
}
|
||
|
||
// GovernanceConfig 治理配置
|
||
type GovernanceConfig struct {
|
||
InitialLevel GovernanceLevel
|
||
}
|
||
|
||
// DefaultGovernanceConfig 返回默认治理配置
|
||
func DefaultGovernanceConfig() *GovernanceConfig {
|
||
return &GovernanceConfig{
|
||
InitialLevel: GovLevelNormal,
|
||
}
|
||
}
|
||
|
||
// NewGovernanceManager 创建治理管理器
|
||
func NewGovernanceManager(config *GovernanceConfig) *GovernanceManager {
|
||
if config == nil {
|
||
config = DefaultGovernanceConfig()
|
||
}
|
||
return &GovernanceManager{
|
||
level: config.InitialLevel,
|
||
policies: make(map[string]GovernancePolicy),
|
||
blacklist: make(map[string]bool),
|
||
whitelist: make(map[string]bool),
|
||
config: config,
|
||
}
|
||
}
|
||
|
||
// SetLevel 设置治理级别
|
||
func (gm *GovernanceManager) SetLevel(level GovernanceLevel) {
|
||
gm.mu.Lock()
|
||
defer gm.mu.Unlock()
|
||
|
||
gm.level = level
|
||
log.Printf("[灵枢] 治理级别调整为: %s", level.String())
|
||
}
|
||
|
||
// GetLevel 获取治理级别
|
||
func (gm *GovernanceManager) GetLevel() GovernanceLevel {
|
||
gm.mu.RLock()
|
||
defer gm.mu.RUnlock()
|
||
return gm.level
|
||
}
|
||
|
||
// AddPolicy 添加治理策略
|
||
func (gm *GovernanceManager) AddPolicy(policy GovernancePolicy) {
|
||
gm.mu.Lock()
|
||
defer gm.mu.Unlock()
|
||
gm.policies[policy.ID] = policy
|
||
}
|
||
|
||
// RemovePolicy 移除治理策略
|
||
func (gm *GovernanceManager) RemovePolicy(policyID string) {
|
||
gm.mu.Lock()
|
||
defer gm.mu.Unlock()
|
||
delete(gm.policies, policyID)
|
||
}
|
||
|
||
// BanAgent 封禁 Agent
|
||
func (gm *GovernanceManager) BanAgent(agentID, reason string) {
|
||
gm.mu.Lock()
|
||
defer gm.mu.Unlock()
|
||
gm.blacklist[agentID] = true
|
||
log.Printf("[灵枢] 封禁 Agent: %s (%s)", agentID, reason)
|
||
}
|
||
|
||
// UnbanAgent 解封 Agent
|
||
func (gm *GovernanceManager) UnbanAgent(agentID string) {
|
||
gm.mu.Lock()
|
||
defer gm.mu.Unlock()
|
||
delete(gm.blacklist, agentID)
|
||
log.Printf("[灵枢] 解封 Agent: %s", agentID)
|
||
}
|
||
|
||
// IsBanned 检查是否被封禁
|
||
func (gm *GovernanceManager) IsBanned(agentID string) bool {
|
||
gm.mu.RLock()
|
||
defer gm.mu.RUnlock()
|
||
return gm.blacklist[agentID]
|
||
}
|
||
|
||
// AllowMessage 检查是否允许消息通过
|
||
func (gm *GovernanceManager) AllowMessage(ctx context.Context, msg *types.UnifiedSynapseMessage) (bool, string) {
|
||
gm.mu.RLock()
|
||
defer gm.mu.RUnlock()
|
||
|
||
// 停机模式，全部拒绝
|
||
if gm.level >= GovLevelShutdown {
|
||
return false, "system shutdown"
|
||
}
|
||
|
||
// 检查黑名单
|
||
if gm.blacklist[msg.Sender.AgentID] {
|
||
return false, "sender banned"
|
||
}
|
||
|
||
// 紧急模式，仅允许白名单
|
||
if gm.level >= GovLevelEmergency {
|
||
if !gm.whitelist[msg.Sender.AgentID] {
|
||
return false, "emergency mode, whitelist only"
|
||
}
|
||
}
|
||
|
||
// 执行策略检查
|
||
for _, policy := range gm.policies {
|
||
if !policy.Enabled || policy.Level > gm.level {
|
||
continue
|
||
}
|
||
allowed, reason := policy.Evaluate(ctx, msg)
|
||
if !allowed {
|
||
return false, fmt.Sprintf("policy %s: %s", policy.Name, reason)
|
||
}
|
||
}
|
||
|
||
return true, ""
|
||
}
|
||
|
||
// =============================================================================
|
||
// Protocol Upgrade - 协议升级
|
||
// =============================================================================
|
||
|
||
// UpgradeManager 升级管理器
|
||
type UpgradeManager struct {
|
||
mu sync.RWMutex
|
||
currentVersion string
|
||
upgrades map[string]ProtocolUpgrade
|
||
config *UpgradeConfig
|
||
}
|
||
|
||
// ProtocolUpgrade 协议升级
|
||
type ProtocolUpgrade struct {
|
||
Version string
|
||
Description string
|
||
ReleasedAt time.Time
|
||
Mandatory bool
|
||
Apply func() error
|
||
Rollback func() error
|
||
}
|
||
|
||
// UpgradeConfig 升级配置
|
||
type UpgradeConfig struct {
|
||
AutoUpgrade bool
|
||
}
|
||
|
||
// DefaultUpgradeConfig 返回默认升级配置
|
||
func DefaultUpgradeConfig() *UpgradeConfig {
|
||
return &UpgradeConfig{
|
||
AutoUpgrade: false,
|
||
}
|
||
}
|
||
|
||
// NewUpgradeManager 创建升级管理器
|
||
func NewUpgradeManager(initialVersion string, config *UpgradeConfig) *UpgradeManager {
|
||
if config == nil {
|
||
config = DefaultUpgradeConfig()
|
||
}
|
||
return &UpgradeManager{
|
||
currentVersion: initialVersion,
|
||
upgrades: make(map[string]ProtocolUpgrade),
|
||
config: config,
|
||
}
|
||
}
|
||
|
||
// CurrentVersion 当前版本
|
||
func (um *UpgradeManager) CurrentVersion() string {
|
||
um.mu.RLock()
|
||
defer um.mu.RUnlock()
|
||
return um.currentVersion
|
||
}
|
||
|
||
// RegisterUpgrade 注册升级
|
||
func (um *UpgradeManager) RegisterUpgrade(upgrade ProtocolUpgrade) {
|
||
um.mu.Lock()
|
||
defer um.mu.Unlock()
|
||
um.upgrades[upgrade.Version] = upgrade
|
||
}
|
||
|
||
// ApplyUpgrade 应用升级
|
||
func (um *UpgradeManager) ApplyUpgrade(version string) error {
|
||
um.mu.Lock()
|
||
defer um.mu.Unlock()
|
||
|
||
upgrade, ok := um.upgrades[version]
|
||
if !ok {
|
||
return fmt.Errorf("upgrade %s not found", version)
|
||
}
|
||
|
||
if upgrade.Apply == nil {
|
||
um.currentVersion = version
|
||
log.Printf("[灵枢] 协议升级到: %s", version)
|
||
return nil
|
||
}
|
||
|
||
if err := upgrade.Apply(); err != nil {
|
||
return fmt.Errorf("upgrade failed: %w", err)
|
||
}
|
||
|
||
um.currentVersion = version
|
||
log.Printf("[灵枢] 协议升级成功: %s", version)
|
||
return nil
|
||
}
|
||
|
||
// RollbackUpgrade 回滚升级
|
||
func (um *UpgradeManager) RollbackUpgrade(version string) error {
|
||
um.mu.Lock()
|
||
defer um.mu.Unlock()
|
||
|
||
upgrade, ok := um.upgrades[version]
|
||
if !ok {
|
||
return fmt.Errorf("upgrade %s not found", version)
|
||
}
|
||
|
||
if upgrade.Rollback == nil {
|
||
return fmt.Errorf("no rollback function for version %s", version)
|
||
}
|
||
|
||
if err := upgrade.Rollback(); err != nil {
|
||
return fmt.Errorf("rollback failed: %w", err)
|
||
}
|
||
|
||
log.Printf("[灵枢] 协议回滚: %s", version)
|
||
return nil
|
||
}
|
||
|
||
// =============================================================================
|
||
// Pivot - 灵枢整体入口
|
||
// =============================================================================
|
||
|
||
// Pivot 灵枢 - 紧急制动与治理
|
||
type Pivot struct {
|
||
CircuitBreakers map[string]*CircuitBreaker
|
||
Governance *GovernanceManager
|
||
Upgrade *UpgradeManager
|
||
mu sync.RWMutex
|
||
}
|
||
|
||
// NewPivot 创建灵枢
|
||
func NewPivot() *Pivot {
|
||
return &Pivot{
|
||
CircuitBreakers: make(map[string]*CircuitBreaker),
|
||
Governance: NewGovernanceManager(nil),
|
||
Upgrade: NewUpgradeManager("1.0.0", nil),
|
||
}
|
||
}
|
||
|
||
// GetCircuitBreaker 获取或创建熔断器
|
||
func (p *Pivot) GetCircuitBreaker(name string) *CircuitBreaker {
|
||
p.mu.Lock()
|
||
defer p.mu.Unlock()
|
||
|
||
if cb, ok := p.CircuitBreakers[name]; ok {
|
||
return cb
|
||
}
|
||
|
||
cb := NewCircuitBreaker(name, nil)
|
||
p.CircuitBreakers[name] = cb
|
||
return cb
|
||
}
|
||
|
||
// EmergencyStop 紧急停止（一键熔断所有）
|
||
func (p *Pivot) EmergencyStop(reason string) {
|
||
log.Printf("[灵枢] ⚠️ 紧急制动启动: %s", reason)
|
||
p.Governance.SetLevel(GovLevelEmergency)
|
||
|
||
for name, cb := range p.CircuitBreakers {
|
||
cb.RecordFailure()
|
||
log.Printf("[灵枢] 熔断器 %s 已熔断", name)
|
||
}
|
||
}
|
||
|
||
// Resume 恢复正常
|
||
func (p *Pivot) Resume() {
|
||
log.Printf("[灵枢] 系统恢复正常")
|
||
p.Governance.SetLevel(GovLevelNormal)
|
||
|
||
for _, cb := range p.CircuitBreakers {
|
||
cb.Reset()
|
||
}
|
||
}
|
||
|
||
// ToJSON 导出为 JSON
|
||
func (gm *GovernanceManager) ToJSON() string {
|
||
data, _ := json.MarshalIndent(map[string]interface{}{
|
||
"level": gm.level.String(),
|
||
"policies": len(gm.policies),
|
||
"blacklist": len(gm.blacklist),
|
||
"whitelist": len(gm.whitelist),
|
||
}, "", " ")
|
||
return string(data)
|
||
}
|