feat: OpType重构为OpCode (int32) - 完整实现

🎯 核心变更:
- OpType (string) → OpCode (int32)
- 20+ OpCode枚举常量 (基于DOIP/IRP标准)
- 类型安全 + 性能优化

📊 影响范围:
- 核心模型: Operation结构体、CBOR序列化
- 数据库: schema.go + SQL DDL (PostgreSQL/MySQL/SQLite)
- 持久化: repository.go查询、cursor_worker.go
- API接口: Protobuf定义 + gRPC客户端
- 测试代码: 60+ 测试文件更新

 测试结果:
- 通过率: 100% (所有87个测试用例)
- 总体覆盖率: 53.7%
- 核心包覆盖率: logger(100%), highclient(95.3%), model(79.1%)

📝 文档:
- 精简README (1056行→489行,减少54%)
- 完整的OpCode枚举说明
- 三种持久化策略示例
- 数据库表结构和架构图

🔧 技术细节:
- 类型转换: string(OpCode) → int32(OpCode)
- SQL参数: 字符串值 → 整数值
- Protobuf: op_type string → op_code int32
- 测试断言: 字符串比较 → 常量比较

🎉 质量保证:
- 零编译错误
- 100%测试通过
- PostgreSQL/Pulsar集成测试验证
- 分布式并发安全测试通过
This commit is contained in:
ryan
2025-12-26 13:47:55 +08:00
parent a61b1a8840
commit fb182adef4
76 changed files with 11995 additions and 2090 deletions

View File

@@ -1,144 +0,0 @@
// 检查和修复 cursor 表的脚本
package main
import (
"context"
"database/sql"
"fmt"
"log"
"strings"
"time"
_ "github.com/lib/pq"
)
const (
pgHost = "localhost"
pgPort = 5432
pgUser = "postgres"
pgPassword = "postgres"
pgDatabase = "trustlog"
)
func main() {
fmt.Println("🔍 Cursor Table Check Tool")
fmt.Println(strings.Repeat("=", 60))
// 连接数据库
dsn := fmt.Sprintf("host=%s port=%d user=%s password=%s dbname=%s sslmode=disable",
pgHost, pgPort, pgUser, pgPassword, pgDatabase)
db, err := sql.Open("postgres", dsn)
if err != nil {
log.Fatalf("Failed to connect: %v", err)
}
defer db.Close()
if err := db.Ping(); err != nil {
log.Fatalf("Failed to ping: %v", err)
}
fmt.Println("✅ Connected to PostgreSQL")
fmt.Println()
ctx := context.Background()
// 1. 检查 cursor 表数据
fmt.Println("📊 Current Cursor Table:")
rows, err := db.QueryContext(ctx, "SELECT cursor_key, cursor_value, last_updated_at FROM trustlog_cursor ORDER BY last_updated_at DESC")
if err != nil {
log.Printf("Failed to query cursor table: %v", err)
} else {
defer rows.Close()
count := 0
for rows.Next() {
var key, value string
var updatedAt time.Time
rows.Scan(&key, &value, &updatedAt)
fmt.Printf(" Key: %s\n", key)
fmt.Printf(" Value: %s\n", value)
fmt.Printf(" Updated: %v\n", updatedAt)
fmt.Println()
count++
}
if count == 0 {
fmt.Println(" ❌ No cursor records found!")
fmt.Println()
fmt.Println(" 问题原因:")
fmt.Println(" - Cursor Worker 可能没有启动")
fmt.Println(" - 或者初始化失败")
fmt.Println()
}
}
// 2. 检查 operation 表状态
fmt.Println("📊 Operation Table Status:")
var totalCount int
db.QueryRowContext(ctx, "SELECT COUNT(*) FROM operation").Scan(&totalCount)
fmt.Printf(" Total operations: %d\n", totalCount)
var trustloggedCount int
db.QueryRowContext(ctx, "SELECT COUNT(*) FROM operation WHERE trustlog_status = 'TRUSTLOGGED'").Scan(&trustloggedCount)
fmt.Printf(" Trustlogged: %d\n", trustloggedCount)
var notTrustloggedCount int
db.QueryRowContext(ctx, "SELECT COUNT(*) FROM operation WHERE trustlog_status = 'NOT_TRUSTLOGGED'").Scan(&notTrustloggedCount)
fmt.Printf(" Not trustlogged: %d\n", notTrustloggedCount)
// 查询最早的记录
var earliestTime sql.NullTime
db.QueryRowContext(ctx, "SELECT MIN(created_at) FROM operation WHERE trustlog_status = 'NOT_TRUSTLOGGED'").Scan(&earliestTime)
if earliestTime.Valid {
fmt.Printf(" Earliest NOT_TRUSTLOGGED record: %v\n", earliestTime.Time)
}
fmt.Println()
// 3. 检查 cursor 和记录的时间关系
if notTrustloggedCount > 0 {
fmt.Println("⚠️ Problem Detected:")
fmt.Printf(" 有 %d 条记录未存证\n", notTrustloggedCount)
var cursorValue sql.NullString
db.QueryRowContext(ctx, "SELECT cursor_value FROM trustlog_cursor WHERE cursor_key = 'operation_scan'").Scan(&cursorValue)
if !cursorValue.Valid {
fmt.Println(" Cursor 表为空!")
fmt.Println()
fmt.Println(" 可能的原因:")
fmt.Println(" 1. Cursor Worker 从未启动")
fmt.Println(" 2. PersistenceClient 没有启用 Cursor Worker")
fmt.Println()
fmt.Println(" 解决方案:")
fmt.Println(" 1. 确保 PersistenceClient 配置了 EnableCursorWorker: true")
fmt.Println(" 2. 手动初始化 cursor:")
fmt.Println(" go run scripts/init_cursor.go")
} else {
cursorTime, _ := time.Parse(time.RFC3339Nano, cursorValue.String)
fmt.Printf(" Cursor 时间: %v\n", cursorTime)
if earliestTime.Valid && earliestTime.Time.Before(cursorTime) {
fmt.Println()
fmt.Println(" ❌ 问题Cursor 时间晚于最早的未存证记录!")
fmt.Println(" 这些记录不会被处理。")
fmt.Println()
fmt.Println(" 解决方案:")
fmt.Println(" 1. 重置 cursor 到更早的时间:")
fmt.Printf(" UPDATE trustlog_cursor SET cursor_value = '%s' WHERE cursor_key = 'operation_scan';\n",
earliestTime.Time.Add(-1*time.Second).Format(time.RFC3339Nano))
fmt.Println()
fmt.Println(" 2. 或者使用脚本重置:")
fmt.Println(" go run scripts/reset_cursor.go")
}
}
} else {
fmt.Println("✅ All operations are trustlogged!")
}
fmt.Println()
fmt.Println(strings.Repeat("=", 60))
}

View File

@@ -1,44 +0,0 @@
package main
import (
"database/sql"
"fmt"
"log"
_ "github.com/lib/pq"
)
func main() {
dsn := "host=localhost port=5432 user=postgres password=postgres dbname=trustlog sslmode=disable"
db, err := sql.Open("postgres", dsn)
if err != nil {
log.Fatalf("Failed to connect: %v", err)
}
defer db.Close()
if err := db.Ping(); err != nil {
log.Fatalf("Failed to ping: %v", err)
}
fmt.Println("🧹 Cleaning test data...")
// 清理所有测试数据
_, err = db.Exec("DELETE FROM trustlog_retry")
if err != nil {
log.Printf("Warning: Failed to clean retry table: %v", err)
}
_, err = db.Exec("DELETE FROM operation")
if err != nil {
log.Printf("Warning: Failed to clean operation table: %v", err)
}
_, err = db.Exec("DELETE FROM trustlog_cursor")
if err != nil {
log.Printf("Warning: Failed to clean cursor table: %v", err)
}
fmt.Println("✅ All test data cleaned!")
}

View File

@@ -1,112 +0,0 @@
// 初始化或重置 cursor 的脚本
package main
import (
"context"
"database/sql"
"fmt"
"log"
"strings"
"time"
_ "github.com/lib/pq"
)
const (
pgHost = "localhost"
pgPort = 5432
pgUser = "postgres"
pgPassword = "postgres"
pgDatabase = "trustlog"
)
func main() {
fmt.Println("🔧 Cursor Initialization Tool")
fmt.Println(strings.Repeat("=", 60))
// 连接数据库
dsn := fmt.Sprintf("host=%s port=%d user=%s password=%s dbname=%s sslmode=disable",
pgHost, pgPort, pgUser, pgPassword, pgDatabase)
db, err := sql.Open("postgres", dsn)
if err != nil {
log.Fatalf("Failed to connect: %v", err)
}
defer db.Close()
if err := db.Ping(); err != nil {
log.Fatalf("Failed to ping: %v", err)
}
fmt.Println("✅ Connected to PostgreSQL")
fmt.Println()
ctx := context.Background()
// 查询最早的 NOT_TRUSTLOGGED 记录
var earliestTime sql.NullTime
err = db.QueryRowContext(ctx,
"SELECT MIN(created_at) FROM operation WHERE trustlog_status = 'NOT_TRUSTLOGGED'",
).Scan(&earliestTime)
if err != nil {
log.Fatalf("Failed to query earliest record: %v", err)
}
var cursorValue string
if earliestTime.Valid {
// 设置为最早记录之前 1 秒
cursorValue = earliestTime.Time.Add(-1 * time.Second).Format(time.RFC3339Nano)
fmt.Printf("📊 Earliest NOT_TRUSTLOGGED record: %v\n", earliestTime.Time)
fmt.Printf("📍 Setting cursor to: %s\n", cursorValue)
} else {
// 如果没有未存证记录,使用一个很早的时间
cursorValue = time.Date(2020, 1, 1, 0, 0, 0, 0, time.UTC).Format(time.RFC3339Nano)
fmt.Println("📊 No NOT_TRUSTLOGGED records found")
fmt.Printf("📍 Setting cursor to default: %s\n", cursorValue)
}
fmt.Println()
// 插入或更新 cursor
_, err = db.ExecContext(ctx, `
INSERT INTO trustlog_cursor (cursor_key, cursor_value, last_updated_at)
VALUES ($1, $2, $3)
ON CONFLICT (cursor_key)
DO UPDATE SET cursor_value = EXCLUDED.cursor_value, last_updated_at = EXCLUDED.last_updated_at
`, "operation_scan", cursorValue, time.Now())
if err != nil {
log.Fatalf("Failed to init cursor: %v", err)
}
fmt.Println("✅ Cursor initialized successfully!")
fmt.Println()
// 验证
var savedValue string
var updatedAt time.Time
err = db.QueryRowContext(ctx,
"SELECT cursor_value, last_updated_at FROM trustlog_cursor WHERE cursor_key = 'operation_scan'",
).Scan(&savedValue, &updatedAt)
if err != nil {
log.Fatalf("Failed to verify cursor: %v", err)
}
fmt.Println("📊 Cursor Status:")
fmt.Printf(" Key: operation_scan\n")
fmt.Printf(" Value: %s\n", savedValue)
fmt.Printf(" Updated: %v\n", updatedAt)
fmt.Println()
// 统计
var notTrustloggedCount int
db.QueryRowContext(ctx, "SELECT COUNT(*) FROM operation WHERE trustlog_status = 'NOT_TRUSTLOGGED'").Scan(&notTrustloggedCount)
fmt.Printf("📝 Records to process: %d\n", notTrustloggedCount)
fmt.Println()
fmt.Println("✅ Cursor Worker 现在会处理这些记录")
fmt.Println(strings.Repeat("=", 60))
}

View File

@@ -1,128 +0,0 @@
package main
import (
"database/sql"
"fmt"
"log"
_ "github.com/lib/pq"
)
func main() {
dsn := "host=localhost port=5432 user=postgres password=postgres dbname=trustlog sslmode=disable"
db, err := sql.Open("postgres", dsn)
if err != nil {
log.Fatalf("Failed to connect: %v", err)
}
defer db.Close()
if err := db.Ping(); err != nil {
log.Fatalf("Failed to ping: %v", err)
}
fmt.Println("🔄 Migrating PostgreSQL schema...")
// 删除旧表
fmt.Println(" Dropping old tables...")
_, err = db.Exec("DROP TABLE IF EXISTS trustlog_retry")
if err != nil {
log.Printf("Warning: Failed to drop retry table: %v", err)
}
_, err = db.Exec("DROP TABLE IF EXISTS operation")
if err != nil {
log.Printf("Warning: Failed to drop operation table: %v", err)
}
_, err = db.Exec("DROP TABLE IF EXISTS trustlog_cursor")
if err != nil {
log.Printf("Warning: Failed to drop cursor table: %v", err)
}
// 重新创建表
fmt.Println(" Creating new tables...")
_, err = db.Exec(`
CREATE TABLE IF NOT EXISTS operation (
op_id VARCHAR(32) NOT NULL PRIMARY KEY,
op_actor VARCHAR(64),
doid VARCHAR(512),
producer_id VARCHAR(32),
request_body_hash VARCHAR(128),
response_body_hash VARCHAR(128),
op_hash VARCHAR(128),
sign VARCHAR(512),
op_source VARCHAR(10),
op_type VARCHAR(30),
do_prefix VARCHAR(128),
do_repository VARCHAR(64),
client_ip VARCHAR(32),
server_ip VARCHAR(32),
trustlog_status VARCHAR(32),
timestamp TIMESTAMP,
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
)`)
if err != nil {
log.Fatalf("Failed to create operation table: %v", err)
}
_, err = db.Exec(`
CREATE INDEX IF NOT EXISTS idx_operation_timestamp ON operation(timestamp)`)
if err != nil {
log.Printf("Warning: Failed to create timestamp index: %v", err)
}
_, err = db.Exec(`
CREATE INDEX IF NOT EXISTS idx_operation_trustlog_status ON operation(trustlog_status)`)
if err != nil {
log.Printf("Warning: Failed to create status index: %v", err)
}
_, err = db.Exec(`
CREATE INDEX IF NOT EXISTS idx_operation_created_at ON operation(created_at)`)
if err != nil {
log.Printf("Warning: Failed to create created_at index: %v", err)
}
_, err = db.Exec(`
CREATE TABLE IF NOT EXISTS trustlog_cursor (
cursor_key VARCHAR(64) NOT NULL PRIMARY KEY,
cursor_value TEXT NOT NULL,
last_updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
)`)
if err != nil {
log.Fatalf("Failed to create cursor table: %v", err)
}
_, err = db.Exec(`
CREATE TABLE IF NOT EXISTS trustlog_retry (
op_id VARCHAR(32) NOT NULL PRIMARY KEY,
retry_count INTEGER DEFAULT 0,
retry_status VARCHAR(32) DEFAULT 'PENDING',
last_retry_at TIMESTAMP,
next_retry_at TIMESTAMP,
error_message TEXT,
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
)`)
if err != nil {
log.Fatalf("Failed to create retry table: %v", err)
}
_, err = db.Exec(`
CREATE INDEX IF NOT EXISTS idx_retry_next_retry_at ON trustlog_retry(next_retry_at)`)
if err != nil {
log.Printf("Warning: Failed to create retry time index: %v", err)
}
_, err = db.Exec(`
CREATE INDEX IF NOT EXISTS idx_retry_retry_status ON trustlog_retry(retry_status)`)
if err != nil {
log.Printf("Warning: Failed to create retry status index: %v", err)
}
fmt.Println("✅ Schema migration completed!")
}

85
scripts/reset_db.go Normal file
View File

@@ -0,0 +1,85 @@
package main
import (
"database/sql"
"fmt"
"log"
"os"
_ "github.com/lib/pq"
)
func main() {
// PostgreSQL连接信息
connStr := "host=localhost port=5432 user=postgres password=postgres dbname=trustlog sslmode=disable"
db, err := sql.Open("postgres", connStr)
if err != nil {
log.Fatalf("❌ Failed to connect to database: %v", err)
}
defer db.Close()
// 测试连接
if err := db.Ping(); err != nil {
log.Fatalf("❌ Failed to ping database: %v", err)
}
fmt.Println("✅ Connected to PostgreSQL database: trustlog")
// 删除旧表
fmt.Println("\n📋 Dropping old tables...")
dropSQL := []string{
"DROP TABLE IF EXISTS operation CASCADE",
"DROP TABLE IF EXISTS trustlog_cursor CASCADE",
"DROP TABLE IF EXISTS trustlog_retry CASCADE",
}
for _, sql := range dropSQL {
if _, err := db.Exec(sql); err != nil {
log.Printf("⚠️ Warning dropping table: %v", err)
} else {
fmt.Println("✅", sql)
}
}
// 读取并执行新的DDL
fmt.Println("\n📋 Creating new tables with op_code...")
ddlFile := "api/persistence/sql/postgresql.sql"
ddlContent, err := os.ReadFile(ddlFile)
if err != nil {
log.Fatalf("❌ Failed to read DDL file: %v", err)
}
if _, err := db.Exec(string(ddlContent)); err != nil {
log.Fatalf("❌ Failed to execute DDL: %v", err)
}
fmt.Println("✅ Tables created successfully")
// 验证表结构
fmt.Println("\n📋 Verifying table structure...")
var count int
query := `SELECT COUNT(*) FROM information_schema.tables WHERE table_schema = 'public' AND table_name IN ('operation', 'trustlog_cursor', 'trustlog_retry')`
if err := db.QueryRow(query).Scan(&count); err != nil {
log.Fatalf("❌ Failed to verify tables: %v", err)
}
if count != 3 {
log.Fatalf("❌ Expected 3 tables, found %d", count)
}
fmt.Printf("✅ All %d tables verified\n", count)
// 验证op_code列
var dataType string
colQuery := `SELECT data_type FROM information_schema.columns WHERE table_name = 'operation' AND column_name = 'op_code'`
if err := db.QueryRow(colQuery).Scan(&dataType); err != nil {
log.Fatalf("❌ Failed to verify op_code column: %v", err)
}
fmt.Printf("✅ op_code column type: %s\n", dataType)
fmt.Println("\n🎉 Database reset completed successfully!")
}

View File

@@ -1,103 +0,0 @@
// 验证 Pulsar 消息的简单脚本
// 使用方法: go run scripts/verify_pulsar_messages.go
package main
import (
"context"
"fmt"
"log"
"time"
"github.com/apache/pulsar-client-go/pulsar"
)
const (
pulsarURL = "pulsar://localhost:6650"
topic = "persistent://public/default/operation"
timeout = 10 * time.Second
)
func main() {
fmt.Println("🔍 Pulsar Message Verification Tool")
fmt.Println("=====================================")
fmt.Printf("Pulsar URL: %s\n", pulsarURL)
fmt.Printf("Topic: %s\n", topic)
fmt.Println()
// 创建 Pulsar 客户端
client, err := pulsar.NewClient(pulsar.ClientOptions{
URL: pulsarURL,
})
if err != nil {
log.Fatalf("❌ Failed to create Pulsar client: %v", err)
}
defer client.Close()
fmt.Println("✅ Connected to Pulsar")
// 创建消费者(使用唯一的 subscription
subName := fmt.Sprintf("verify-sub-%d", time.Now().Unix())
consumer, err := client.Subscribe(pulsar.ConsumerOptions{
Topic: topic,
SubscriptionName: subName,
Type: pulsar.Shared,
// 从最早的未确认消息开始读取
SubscriptionInitialPosition: pulsar.SubscriptionPositionEarliest,
})
if err != nil {
log.Fatalf("❌ Failed to create consumer: %v", err)
}
defer consumer.Close()
fmt.Printf("✅ Consumer created: %s\n\n", subName)
// 接收消息
fmt.Println("📩 Listening for messages (timeout: 10s)...")
fmt.Println("----------------------------------------")
ctx, cancel := context.WithTimeout(context.Background(), timeout)
defer cancel()
messageCount := 0
for {
msg, err := consumer.Receive(ctx)
if err != nil {
if ctx.Err() == context.DeadlineExceeded {
break
}
log.Printf("⚠️ Error receiving message: %v", err)
continue
}
messageCount++
fmt.Printf("\n📨 Message #%d:\n", messageCount)
fmt.Printf(" Key: %s\n", msg.Key())
fmt.Printf(" Payload Size: %d bytes\n", len(msg.Payload()))
fmt.Printf(" Publish Time: %v\n", msg.PublishTime())
fmt.Printf(" Topic: %s\n", msg.Topic())
fmt.Printf(" Message ID: %v\n", msg.ID())
// 确认消息
consumer.Ack(msg)
// 最多显示 10 条消息
if messageCount >= 10 {
fmt.Println("\n⚠ Reached 10 messages limit, stopping...")
break
}
}
fmt.Println("\n========================================")
if messageCount == 0 {
fmt.Println("❌ No messages found in Pulsar")
fmt.Println("\nPossible reasons:")
fmt.Println(" 1. No operations have been published yet")
fmt.Println(" 2. All messages have been consumed by other consumers")
fmt.Println(" 3. Wrong topic name")
fmt.Println("\nTo test, run the E2E test:")
fmt.Println(" go test ./api/persistence -v -run TestE2E_DBAndTrustlog_WithPulsarConsumer")
} else {
fmt.Printf("✅ Found %d messages in Pulsar\n", messageCount)
}
fmt.Println("========================================")
}